C语言在线测试题目及答案_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
C语言在线测试题目及答案
上传于||文档简介
&&关​于​C​语​言​程​序​的​语​句​,​正​确​的​说​法​是​
​
​已​知​“​i​n​t​ ​n​;​”​。​若​通​过​s​c​a​n​f​函​数​为​变​量​n​输​入​值​,​则​
​
​设​i​n​t​ ​a​=,​b​=,​c​=;​,​则​下​面​的​表​达​式​中​,​值​为的​表​达​式​是​
​
​当​c​的​值​不​为时​,​则​在​下​列​选​项​中​,​能​正​确​将​c​的​值​赋​给​变​量​a​、​b​的​是​
​
​根​据​定​义​：​ ​s​t​r​u​c​t​ ​p​e​r​s​o​n​{​c​h​a​r​ ​n​a​m​e​[]​;​i​n​t​ ​a​g​e​;​}
大小：13.57KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢1[1].VBA编程基础-常量、变量、运算符和表达式_图文_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
1[1].VBA编程基础-常量、变量、运算符和表达式
上传于||暂无简介
大小：151.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢1927人阅读
C#学习（2）
&&&&&&& 学习c#视频有几天了，看完其语言基础之后，我对c#语言基础做了一个总结，来巩固所记的知识，同时希望能给你帮助。
&&& 最近一直在看c#视频，开始时看不懂，后来找师傅讨论了一下，自己重新看是有感觉，所以又重新开始。针对这两天的学习对c#语言基础做一下总结。
&&&&&&& 数据类型&&&
&&& 构成：数据类型，常量和变量，运算符和表达式，数组、结构和枚举&
&&& 数据类型包括值类型、引用类型和装箱以及拆箱。
值类型数据存储在栈中。栈：它是用于存储固定长度的数据，例如int(每个int占用四个字节)，每个程序在执行时都有自己的堆栈，其他程序不能访问该堆栈。
&&& 引用类型数据存储在堆中。堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。（虽然对于堆得解释字数也不多，但是始终感觉堆理解其堆来有点儿抽象，不怎么明白。）
&&&&&&& 值类型
&&& 值类型就是一个包含实际数据的量。当我们定义一个值类型的变量时，c#会根据它声明的类型，以堆栈方式分配一块儿相应的存储区域给这个变量。（这里对于堆栈的理解只能是有一点，但是还表达不出来，希望高手指点。）
&&&&&&& 值类型包括：简单类型、枚举类型和结构类型。
&&&&&&& 简单类型
&&&&&&&&在C#中出现的简单类型共享一些特性。第一，它们都是.NET系统类型的别名。第二，由简单类型组成的常量表达式仅在编译时而不是运行时受检测。最后，简单类型可以按字面被初始化。以下为C#简单类型归类：
&&&&&&& 简单类型是系统预置的，分为整数类型、浮点类型、小数类型（decimal类型）、字符类型和布尔类型。提高班第一年有一些VB的基础，这里我感觉可以和VB比较记忆。
&&&&&&& 通过比较我们可以发现。
1.&&&&&&VB中整型、长整型、字节型和C#整型所表示的意思（范围）是一致。
2.&&&&&&VB中单精度和双精度和C#浮点型所表示的意思（范围）是一致的。
3.&&&&&&VB的货币型和C#小数型也是相似的。（不过，很明显C#所表示的货币范围远远超过了VB货币型所表示的范围）
4.&&&&&&VB和C#同样都具有字符串类型和布尔型
5.&&&&& 明显不同的是vb特有日期型。
有了VB的基础理解C#没有什么困难。欠缺的只是对于它们的熟练程度。
&&&&&&&& 结构类型
&&&&&&&& 把一系列相关的信息组织成为一个单一实体的过程，这就是创建一个结构的过程。
struct person
string m_ //姓名
&&&&&& 枚举类型
&&&&&&&& 主要用于表示一个逻辑相关联的项和组合。使用关键字enum来定义。
enum Weekday
Sunday，Monday，Tuesday，Wednesday，Thursday，Friday，Saturday
&&&&& 引用类型
&&&&&&&&引用类型的变量不存储他们所代表的实际数据，而是存储实际数据的引用。引用类型分两步创建：首先在堆栈上创建一个引用变量，然后再堆上创建对象本身，在把这个内存的句柄（内存的首地址）赋给引用变量。
&&&&&&& 例子：
String S1,S2;
S1=”ABCD”;
&&&&&&& 解释：s1和s2都是指向字符串的引用变量，s1的值是字符串“ABCD”存放在内存地址中，这个就是对字符串的引用，两个引用型变量之间的赋值，使得s1和s2都是对“ABCD”的引用。
&&&&&&& 引用类型包括：class(类)、interface（接口）、数组、delegate（委托）、object和string。
&&&&&&& 拆箱和装箱
&&&&&&& 值类型与引用类型之间的转换被称为装箱与拆箱。装箱和拆箱是c#类型系统的核心。我们通过装箱和拆箱操作可以轻松的实现值类型和引用类型的相互转换。
&&&&&&& 例如：
Int Num=123;
//将123值赋给int型变量Num
Object p=N
//装箱动作
Int q=int(p)
//拆箱动作
&&&& 常量和变量
&&&& 常量就是程序运行期间其值不会改变的量。
&&&& 变量是在程序运行过程中其值可以改变的量。
&&& 运算符和表达式
&&&&&&& 算数运算符：
&&&&&&& 关系运算符：
&&&&&&& 逻辑运算符（与（&&）&或（||）非（!））：
&&&&&&& 赋值运算符：
&&&&&&& 条件运算符：
&&&&&&& 条件运算符是一个三元运算符，可以看成一个if……else的简化形式。
&&&&&&&& 格式为：条件？真：假
&&&&&&& 举例：
&&&&&&&& 在控制台中输入以下代码：
int x = 10;
int y = 15;
Console.WriteLine (z = x & y ? x : y);
&&&结果如图，很明显显示的是y说明是假。
&&& 流程控制
&&& 条件语句
&&&&&&&& If语句
&&&&&&& 句式：
&&&&&&& 第一种：
If （条件）语句;
&&&&&&& 第二种：
&&&&&&& 此外在if中还可以嵌套if语句。
&&&&&&&&&&& Switch语句
&&&&&&&&&&& Switch是一个多分支结构的语句。语法结构为：
switch (表达式)
Case常量1：
语句序列1；
Case常量2：
语句序列2；
语句序列n；
&&& 循环语句
&&&&&&&&&& While语句
While (表达式)
循环体语句块
&&&&&&&&&& Do& while语句
循环体语句块
} while (表达式)；
&&&&&&&&&& For
For (表达式1；表达式2；表达式3)
循环体语句
&&&&&&& 其中表达式1是设置循环控制变量的初值，表达式2时布尔类型的表达式，表达式3是设置循环控制变量的增值（正负皆可）。PS:3个表达式都是可选的，默认表达式时，其后的分好“；”不能省。
&&&&&&&& Foreach语句
&&&&&&&& Foreach语句是C#新引入的，它表示收集一个集合中的各元素，并针对各元素执行内嵌语句。
&&&&&& 语法格式：
Foreach (类型
集合表达式)语句；
&&&&&&& 标示符是指foreach循环的迭代变量，它只在foreach语句中有效，并且是一个只读局部变量，也就是说在foreach语句中不能改写这个迭代变量。
&&&&&&& 集合表达式是指被遍历的集合，例如数组。
&&&&&&& 举例：
int m = 0;
string mystring = &fsofknwlsnfoaafdagadf&;
foreach (char mychar in mystring)
if (mychar == 'a')
Console.WriteLine(&字符串中总共有{0}个a&, m);
结果如图：
&&&&&&&& 跳转语句用于改变程序的执行流程，转移制定之处。用于特定的上下文环境之中。
Continue语句
&&&&&&& Continue语句只能用于循环语句中，它的作用是结束本轮循环，不再执行余下的循环体语句，对while和do_while结构的循环，在continue执行之后，就立刻测试循环条件，以决定循环是否继续下去；对for结构循环，在continue执行之后，先求表达式3（循环增量部分），然后再测试循环条件。
例如：显示1-100中能被3整除的整数。
for (int n = 1; n &= 100; n++)
if (n % 3 != 0)
Console.WriteLine(n );
&&&&&&& Break语句也只能用于循环语句中或者switch语句中，如果在循环语句执行到break语句，则会导致循环立刻结束，跳转到循环语句的下一条语句。不管循环多少层，break语句只能从包含它的最内层跳出一层。如果在switch语句中执行到break语句，则立刻从switch语句中跳出，转到switch语句的下一条语句。
看下面的例子：
Return语句
&&&&&&& Return语句出现在一个方法内。在方法中执行到return语句时，程序中的执行流程转到调用这个方法处。如果方法没有返回值（返回类型修饰位void），则使用“return”格式返回；如果方法有返回值，那么使用“return表达式”格式，其后面跟的表达式就是方法的返回值。
&&&&&&& Goto语句可以将程序的执行流程从一个地方转移到另一个地方非常灵活。但正因为它灵活，所以容易造成程序结构混乱的局面，应该有节制地、合理使用goto语句。
&&&&&&& 程序对异常的处理能使程序更加健壮。这里就不做更多的说明
数组、结构和枚举
&&&&&&& 数组：数组是一种包含若干变量的数据结构，这些变量都具有相同的数据类型并且排雷有序，因此可以用一个统一的数组名和下标唯一的确定数组中的元素。
&&&&&&& 数组使用时要先声明然后在创建最后初始化数组，具体语法形式：
Arrayname =new type[size] {
val1,val2,val3,….valn
或者结合起来写：
Type [ ] arrayname = new type [size ] {
val1,val2,val3,….valn
Type可以是C#中任意的数据类型。
[ ] 是表明后面的变量是一个数组类型，必须放在数组名之前。
是数组名，遵循标识符的命名规范。
Size&表明数组原色的个数。
Val 则表示数组的具体值。
具体示例：
course = new int [ 10 ] {1，2，3，4，5，6，7，8，9，10} // student 是一个含有10个int类型的数组。
例子2：创建一个5个数的数组（100，50，60，70，99）并计算出他们的最大值和最小值。
代码如下：
#region 数组的实例
int[] Num = new int[5] { 100, 50, 60, 70, 99 };
max = min = Num[0];
for (int i = 0; i &= 4; i++)
if (Num[i] & max)
max = Num[i];
if (Num[i] & min)
min = Num[i];
Console.WriteLine(&您要求的数组中最大数为& + max + &;最小数为& + min);
#endregion
&&&&&&& 结构和枚举和值类型中说的是一个，这里就不多说了。
&&&&&&& 在总结c#语言基础的过程中，我也不断地看着以前学习的visual basic那本书，不得不说学好了vb在学习c#上就容易许多啊。他们之间好好多相同的地方。在和vb比较的过程中我同时又学到了不少以前不懂的东西。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：76252次
积分：2914
积分：2914
排名：第8547名
原创：55篇
评论：907条
(1)(1)(1)(3)(1)(2)(5)(3)(3)(2)(2)(1)(5)(4)(3)(2)(3)(10)(4)C#算术表达式求值 - C#教程 - 编程入门网
C#算术表达式求值
算术表达式求值是一个经典的问题,很多学习编程的人都对此不陌生.本来我并不想写一个算术表达式求值的算法.在网上我看到了一篇文章,名叫&快速精确的对数学表达式求值&( http://www-/developerworks/cn/java/j-w3eva/ ).才有兴趣着一个玩玩.写来写去,觉得真得很经典.所以把我写的代码拿出来让大家看看吧.因为时间较紧.所以变量名没有做得很规范.
w3eavl是用JAVA写得,我用C#把它重写了一下.基本上能用,只是三角函数/反三角函数/双曲线函数计算不太正常.谁对算术表达式求值感兴趣可以和我联系.原程序截图:
我用C#重写的( 实其是用他的代码改为C#语法. )
谁想要W3Eval的JAVA代码.和我改写的C#代码.可以和我联系.下面要讲的这个逆波兰式求值算法的代码也可以向我索取.请不要在商业中使用我的代码.如果需要使用.请通知我.
我是的算法核心是逆波兰式.还有就是w3eval这个算术表达式求值算法很不错.但有一种表达式它会报错.我想这是一个BUG:w3eavl不能计算&-( 3+5 )&的值.或者类似的计算式.
在生成逆波兰式时,负号前缀是一个很大的麻烦.因为它和减号共用一个符号.我的做法是将负号前缀做一个预处理.负号在我这里做为单目运算符求反.并将其替换还为&!&.
为了可以扩充新的各种级别的运算符我为运算符的优先级做了一个Power( )函数.如果出现了新的优先级级别.只要在这里调整就可以了.
后缀式求值本没有什么好说的.只是.单目运算和双目运算还行三目运算对于它来说就不太好玩了.幸亏三目运算不多.不然,那都是事儿.
　　/// &summary&
　　/// SimpleRPN 的摘要说明.
　　/// &/summary&
　　public sealed class SimpleRPN
　　　　private SimpleRPN( )
　　　　/// &summary&
　　　　/// Reverse Polish Notation　
　　　　/// 算术逆波兰表达式.生成.　
　　　　/// &/summary&
　　　　/// &param name=&s&&&/param&
　　　　/// &returns&&/returns&
　　　　private static
　　　　string BuildingRPN( string s )
　　　　　　System.Text.StringBuilder sb=new System.Text.StringBuilder( s );
　　　　　　System.Collections.Stack sk=new System.Collections.Stack( );
　　　　　　System.Text.StringBuilder re=new System.Text.StringBuilder( );
　　　　　　char c=' ';
　　　　　　//sb.Replace( & &,&& );
　　　　　　//一开始,我只去掉了空格.后来我不想不支持函数和常量能滤掉的全OUT掉.
　　　　　　for( int i=0;
　　　　　　i&sb.L
　　　　　　i++ )
　　　　　　{
　　　　　　　　c=sb[i];
　　　　　　　　if( char.IsDigit( c ) )//数字当然要了.
　　　　　　　　re.Append( c );
　　　　　　　　//if( char.IsWhiteSpace( c )||
　　　　　　　　char.IsLetter( c ) )//如果是空白,那么不要.现在字母也不要.
　　　　　　　　//
　　　　　　　　switch( c )//如果是其它字符...列出的要,没有列出的不要.
　　　　　　　　{
　　　　　　　　　　case '+':
　　　　　　　　　　case '-':
　　　　　　　　　　case '*':
　　　　　　　　　　case '/':
　　　　　　　　　　case '%':
　　　　　　　　　　case '^':
　　　　　　　　　　case '!':
　　　　　　　　　　case '( ':
　　　　　　　　　　case ' )':
　　　　　　　　　　case '.':
　　　　　　　　　　re.Append( c );
　　　　　　　　　　
　　　　　　　　　　default:
　　　　　　　　　　
　　　　　　　　}
　　　　　　}
　　　　　　sb=new System.Text.StringBuilder( re.ToString( ) );
　　　　　　#region 对负号进行预转义处理.负号变单目运算符求反.
　　　　　　for( int i=0;i&sb.Length-1;i++ )
　　　　　　if( sb[i]=='-'&&( i==0||sb[i-1]=='( ' ) )
　　　　　　sb[i]='!';
　　　　　　//字符转义.
　　　　　　#endregion
　　　　　　#region 将中缀表达式变为后缀表达式.
　　　　　　re=new System.Text.StringBuilder( );
　　　　　　for( int i=0;
　　　　　　i&sb.L
　　　　　　i++ )
　　　　　　{
　　　　　　　　if( char.IsDigit( sb[i] )||sb[i]=='.' )//如果是数值.
　　　　　　　　{
　　　　　　　　　　re.Append( sb[i] );
　　　　　　　　　　//加入后缀式
　　　　　　　　}
　　　　　　　　else if( sb[i]=='+'
　　　　　　　　||sb[i]=='-'
　　　　　　　　||sb[i]=='*'
　　　　　　　　||sb[i]=='/'
　　　　　　　　||sb[i]=='%'
　　　　　　　　||sb[i]=='^'
　　　　　　　　||sb[i]=='!' )//.
　　　　　　　　{
　　　　　　　　　　#region 运算符处理
　　　　　　　　　　while ( sk.Count&0 ) //栈不为空时
　　　　　　　　　　{
　　　　　　　　　　　　c = ( char )sk.Pop( );
　　　　　　　　　　　　//将栈中的操作符弹出.
　　　　　　　　　　　　if ( c == '( ' ) //如果发现左括号.停.
　　　　　　　　　　　　{
　　　　　　　　　　　　　　sk.Push( c );
　　　　　　　　　　　　　　//将弹出的左括号压回.因为还有右括号要和它匹配.
　　　　　　　　　　　　　　
　　　　　　　　　　　　　　//中断.
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　if( Power( c )&Power( sb[i] ) )//如果优先级比上次的高,则压栈.
　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　sk.Push( c );
　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　re.Append( ' ' );
　　　　　　　　　　　　　　　　re.Append( c );
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　//如果不是左括号,那么将操作符加入后缀式中.
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　　　sk.Push( sb[i] );
　　　　　　　　　　//把新操作符入栈.
　　　　　　　　　　re.Append( ' ' );
　　　　　　　　　　#endregion
　　　　　　　　}
　　　　　　　　else if( sb[i]=='( ' )//基本优先级提升
　　　　　　　　{
　　　　　　　　　　sk.Push( '( ' );
　　　　　　　　　　re.Append( ' ' );
　　　　　　　　}
　　　　　　　　else if( sb[i]==' )' )//基本优先级下调
　　　　　　　　{
　　　　　　　　　　while ( sk.Count&0 ) //栈不为空时
　　　　　　　　　　{
　　　　　　　　　　　　c = ( char )sk.Pop( );
　　　　　　　　　　　　//pop Operator
　　　　　　　　　　　　if ( c != '( ' )
　　　　　　　　　　　　{
　　　　　　　　　　　　　　re.Append( ' ' );
　　　　　　　　　　　　　　re.Append( c );
　　　　　　　　　　　　　　//加入空格主要是为了防止不相干的数据相临产生解析错误.
　　　　　　　　　　　　　　re.Append( ' ' );
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　
　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　else
　　　　　　　　re.Append( sb[i] );
　　　　　　}
　　　　　　while( sk.Count&0 )//这是最后一个弹栈啦.
　　　　　　{
　　　　　　　　re.Append( ' ' );
　　　　　　　　re.Append( sk.Pop( ) );
　　　　　　}
　　　　　　#endregion
　　　　　　re.Append( ' ' );
　　　　　　return FormatSpace( re.ToString( ) );
　　　　　　//在这里进行一次表达式格式化.这里就是后缀式了.　
　　　　/// &summary&
　　　　/// 算术逆波兰表达式计算.　
　　　　/// &/summary&
　　　　/// &param name=&s&&&/param&
　　　　/// &returns&&/returns&
　　　　public static
　　　　string ComputeRPN( string s )
　　　　　　string S=BuildingRPN( s );
　　　　　　string tmp=&&;
　　　　　　System.Collections.Stack sk=new System.Collections.Stack( );
　　　　　　char c=' ';
　　　　　　System.Text.StringBuilder Operand=new System.Text.StringBuilder( );
　　　　　　double x,y;
　　　　　　for( int i=0;
　　　　　　i&S.L
　　　　　　i++ )
　　　　　　{
　　　　　　　　c=S[i];
　　　　　　　　if( char.IsDigit( c )||c=='.' )
　　　　　　　　{
　　　　　　　　　　//数据值收集.
　　　　　　　　　　Operand.Append( c );
　　　　　　　　}
　　　　　　　　else if( c==' '&&Operand.Length&0 )
　　　　　　　　{
　　　　　　　　　　#region 运算数转换
　　　　　　　　　　try
　　　　　　　　　　{
　　　　　　　　　　　　tmp=Operand.ToString( );
　　　　　　　　　　　　if( tmp.StartsWith( &-& ) )//负数的转换一定要小心...它不被直接支持.
　　　　　　　　　　　　{
　　　　　　　　　　　　　　//现在我的算法里这个分支可能永远不会被执行.
　　　　　　　　　　　　　　sk.Push( -( ( double )Convert.ToDouble( tmp.Sub
　　　　　　　　　　　　　　string( 1,tmp.Length-1 ) ) ) );
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　sk.Push( Convert.ToDouble( tmp ) );
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　　　catch
　　　　　　　　　　{
　　　　　　　　　　　　return &发现异常数据值.&;
　　　　　　　　　　}
　　　　　　　　　　Operand=new System.Text.StringBuilder( );
　　　　　　　　　　#endregion
　　　　　　　　}
　　　　　　　　else if( c=='+'//运算符处理.双目运算处理.
　　　　　　　　||c=='-'
　　　　　　　　||c=='*'
　　　　　　　　||c=='/'
　　　　　　　　||c=='%'
　　　　　　　　||c=='^' )
　　　　　　　　{
　　　　　　　　　　#region 双目运算
　　　　　　　　　　if( sk.Count&0 )/*如果输入的表达式根本没有包含运算符.或是根本就是空串.这里的逻辑就有意义了.*/
　　　　　　　　　　{
　　　　　　　　　　　　y=( double )sk.Pop( );
　　　　　　　　　　}
　　　　　　　　　　else
　　　　　　　　　　{
　　　　　　　　　　　　sk.Push( 0 );
　　　　　　　　　　　　
　　　　　　　　　　}
　　　　　　　　　　if( sk.Count&0 )
　　　　　　　　　　x=( double )sk.Pop( );
　　　　　　　　　　else
　　　　　　　　　　{
　　　　　　　　　　　　sk.Push( y );
　　　　　　　　　　　　
　　　　　　　　　　}
　　　　　　　　　　switch( c )
　　　　　　　　　　{
　　　　　　　　　　　　case '+':
　　　　　　　　　　　　sk.Push( x+y );
　　　　　　　　　　　　
　　　　　　　　　　　　case '-':
　　　　　　　　　　　　sk.Push( x-y );
　　　　　　　　　　　　
　　　　　　　　　　　　case '*':
　　　　　　　　　　　　sk.Push( x*y );
　　　　　　　　　　　　
　　　　　　　　　　　　case '/':
　　　　　　　　　　　　sk.Push( x/y );
　　　　　　　　　　　　
　　　　　　　　　　　　case '%':
　　　　　　　　　　　　sk.Push( x%y );
　　　　　　　　　　　　
　　　　　　　　　　　　case '^'://
　　　　　　　　　　　　if( x&0 )//
　　　　　　　　　　　　{
　　　　　　　　　　　　　　我原本还想,如果被计算的数是负数,又要开真分数次方时如何处理的问题.后来我想还是算了吧.
　　　　　　　　　　　　　　sk.Push( System.Math.Pow( x,y ) );
　　　　　　　　　　　　　　//
　　　　　　　　　　　　}
　　　　　　　　　　　　//
　　　　　　　　　　　　else//
　　　　　　　　　　　　{
　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　double t=y;
　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　string ts=&&;
　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　t=1/( 2*t );
　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　ts=t.ToString( );
　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　if( ts.ToUpper( ).LastIndexOf( 'E' )&0 )//
　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　　　;
　　　　　　　　　　　　　　　　//
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　//
　　　　　　　　　　　　}
　　　　　　　　　　　　
　　　　　　　　　　}
　　　　　　　　　　#endregion
　　　　　　　　}
　　　　　　　　else if( c=='!' )//单目取反. )
　　　　　　　　{
　　　　　　　　　　sk.Push( -( ( double )sk.Pop( ) ) );
　　　　　　　　}
　　　　　　}
　　　　　　if( sk.Count&1 )
　　　　　　return &运算没有完成.&;
　　　　　　if( sk.Count==0 )
　　　　　　return &结果丢失..&;
　　　　　　return sk.Pop( ).ToString( );
　　　　/// &summary&
　　　　/// 优先级别测试函数.　
　　　　/// &/summary&
　　　　/// &param name=&opr&&&/param&
　　　　/// &returns&&/returns&
　　　　private static
　　　　int Power( char opr )
　　　　　　switch( opr )
　　　　　　{
　　　　　　　　case '+':
　　　　　　　　case '-':
　　　　　　　　return 1;
　　　　　　　　case '*':
　　　　　　　　case '/':
　　　　　　　　return 2;
　　　　　　　　case '%':
　　　　　　　　case '^':
　　　　　　　　case '!':
　　　　　　　　return 3;
　　　　　　　　default:
　　　　　　　　return 0;
　　　　　　}
　　　　/// &summary&
　　　　/// 规范化逆波兰表达式.
　　　　/// &/summary&
　　　　/// &param name=&s&&&/param&
　　　　/// &returns&&/returns&
　　　　private static
　　　　string FormatSpace( string s )
　　　　　　System.Text.StringBuilder ret=new System.Text.StringBuilder( );
　　　　　　for( int i=0;
　　　　　　i&s.L
　　　　　　i++ )
　　　　　　{
　　　　　　　　if( !( s.Length&i+1&&s[i]==' '&&s[i+1]==' ' ) )
　　　　　　　　ret.Append( s[i] );
　　　　　　　　else
　　　　　　　　ret.Append( s[i] );
　　　　　　}
　　　　　　return ret.ToString( );
　　　　　　//.Replace( '!','-' );
　　/*这里给出的测试用例虽然不多.但如都能成功计算也不容易.( 6+9-8+5-8 )*( 2+5+8 )/7+5( 1+2+3+4+5+6+7+8+9 )*( 1+2+3+4+5+6+7+8+9 )/( 9+8+7+6 )*3-2-2+5/7-3( -3+4+9 )*( -3 )*7/( -5*2 )-( 6+9-8+5-8 )*( 2+5+8 )1+2+3+4+5+6+7+8+91*2*3*4*5*6*7*8*91-2-3-4-5-6-7-8-91/2/3/4/5/6/7/8/9( 6+9-8+5-8 )*( 2+5+8 ) */