c# 语句详解
8. 语句8. 语句
8.1 终点与可达性
8.2 块
8.2.1 语句列表.
8.3 空语句.
8.4 标号语句.
8.5 声明语句
8.5.1 局部变量声明.
8.5.2 局部常量声明.
8.6 表达式语句
8.7 选择语句
8.7.1 if语句
8.7.2 Switch 语句
8.8 重复语句
8.8.1 while语句
8.8.2 do语句.
8.8.3 for语句
8.8.4 foreach语句.
8.9 跳转语句
8.9.1 break语句.
8.9.2 continue语句.
8.9.3 goto语句
8.9.4 return语句
8.9.5 throw语句
8.10 try语句
8.11 checked和unchecked语句8.12 lock语句.
C# 提供各式各样的语句。当中的绝大部分语句对于那些进行过C和
C++编程的人员来讲都很熟悉。
语句：标号语句声明语句嵌套语句
嵌套语句：块语句空语句表达式语句选择语句重复iteration 语句跳转语句try语句checked语句unchecked语句lock语句嵌入语句出现在语句的内部。与通常意义下的语句不同，嵌入语句不允许在其中出现声明声明语句和带标号语句
比如下列代码
void F(bool b) { if (b) int i = 44; }
有错误，因为if 语句在自身的分支中需要的是嵌入语句而不是通常的语句。假如允许这样的代码，那么变量i会被声明，但是它并不能被适用。
8.1 终点与可达性
每条语句都有终点。更直观地说，语法上语句书写完成的地方就是该语句的终点。对于复合语句（嵌套了其他语句）来说，它的执行规则详尽描述了当嵌套语句到达终点时采取的操作。比如说，当程序执行到一个块中某语句的末尾，那么程序将继续执行块的下一条语句。
如果一条语句可以被执行，那么我们称它为是可达的(reachable)。相反，如果一条语句无法被执行，我们称之为是不可达的(unreachable)。
下面看一个例子
void F() { Console.WriteLine("reachable"); goto Label;
Console.WriteLine("unreachable"); Label:
Console.WriteLine("reachable"); }
第二个Console.WriteLine调用是不可到达的因为这条语句不会被执行。当便要此段代码时，编译器会发出语句无法到达的警告。这并不代表语句本身有错使之无法到达。
判断一个语句是否可以到达，编译器是通过按照可达性规则进行流分析而得出结论的。下面的流分析考虑进来的§错误！未找到引用源。节中决定该语句行为的常数表达式的数值，但是非常数表达式的可能值并未被考虑。换句话说，为了控制流分析，某类型的非常数表达式往往会被认为可以去该类型中的任何值。
请看下面的例子
void F() { const int i = 1; if (i == 2)
Console.WriteLine("unreachable"); }
if语句中的布尔表达式是一个常数表达式因为运算符==的两个操作
数都是常数。该常数表达式在编译是会被取值，它的值为假，因此Console.WriteLine语句对于会被认为是不可到达的。但是如果变量i变成一个局部变量，如下所示
void F() { int i = 1; if (i == 2) Console.WriteLine("reachable"); } Console.WriteLine调用语句将是可以到达的，即使它本身并未被真的
函数子句中的块语句往往总是被认为是可以到达的。通过依次评估块中的每一条语句，任何语句的可达性都可以被确定。
下面的代码段中
Void F(int x) { Console.WriteLine("start"); if (x < 0)
Console.WriteLine("negative");}
第二个Console.WriteLine语句的可达性是这样确定的：
?首先由于method F中的块是可以到达的，所有第一个Console.WriteLine语句是可达的。
?其次，由于第一个Console.WriteLine语句是可达的，它的结尾是可达的。
?再次，由于第一个Console.WriteLine语句的结尾是可达的，if语句是可达的。
?最后，由于if语句中的布尔表达式值为真，第二个Console.WriteLine 语句是可达的。
有两种情况会使程序语句因为可达性发生错误：
?由于switch语句中不允许任意分支之间发生跳转，所以可能会使该switch语句分支语句在可达性检测时出错。如果此错误发生，很典型的情况就是缺少break语句。
块语句把一系列语句包装成一个语句。块的一般格式如下：block: { statement-list
}
opt
块语句包括一个可选的如§错误！未找到引用源。节中的语句列表，它们被包围在一对花括号中。假如此语句列表被省略，我们称块为空。在块当中，某一表达式中出现的某名称含义必须保持一致(详见§7.5.2.1节)。
块是按照下面方式被执行的：
?如果块空，程序跳转到块的结尾。
?如果块非空，程序会依次执行语句列表当中的每一语句。当程序控制到达语句列表结尾时，它将被转移到块的结尾。
如果块本身是可以到达的，那么块中的语句列表也是可以到达的。
如果块为空或者块中语句列表的结尾可以到达，那么该块的结尾也可到达。
8.2.1 语句列表
语句列表包括一系列依次书写的语句。它可以在会或者switch语句中出现（分别详见§错误！未找到引用源。节和§错误！未找到引
用源。节）。其一般格式如下：
statement-list: statement statement-list statement
语句列表都是从第一条语句开始执行的。当执行到该语句的结尾时，程序将会继续执行下一条语句。当程序执行到列表的最后一条语句时，程序控制也被转移到该列表的结尾。
如果下列所述各项条件中的任意一项满足，语句列表中的语句为可到达的：
?语句为列表中的第一条语句，而且语句列表本身可到达。
?语句列表中的上一语句的结尾可到达。
?当语句为带标号的语句时，标号语句被一条可到达的goto语句引用。
如果语句列表中最后一条语句的结尾是可到达的，那么该列表的结尾也可到达。
8.3 空语句
空语句不进行任何操作，其一般格式如下：
empty-statement: ;
在需要语句但又不进行任何操作的时候我们使用空语句。
执行空语句时只需把程序控制转移到语句的结尾。这样如果空语句是可到达的，那么它的结尾也是可以到达的。
在书写一个空的while语句时，我们可以用到空语句：
bool ProcessMessage() {...}
void ProcessMessages() { while (ProcessMessage()); }
同样，在块语句的“}”之前，我们可以通过使用一个空语句来声明一个标号：
void F() { ...
if (done) goto exit; ...
exit: ; }
8.4 标号语句
标号语句允许一条语句使用标号前缀。标号语句可以以块的形式出现，但不能以嵌套语句的形式出现。其格式如下：
labeled-statement: identifier : statement
标号语句通过给定一个标识符identifier来声明它的标号。标号的有效区间为它所在的块内,包括此块的嵌套块。不允许有两个名字相同的标号的有效区间相互重叠。
标号可以在它的的有效区间内被goto语句引用（详见§错误！未找到引用源。节）。这意味着goto语句可以在块内或由块内到块外完成程序控制的转移，但不能把程序控制转移到子块中。
标号声明有自己的规则，与别的标识符无关。详见下面的例子
int F(int x) { if (x >= 0) goto x; x = -x; x: return x; }
上面的例程中x作为参数和标号两次出现，这是符合语法规则有效的。
执行一条标号语句时，就是执行标号后面的语句。
另外，除了通常情况下控制流提供的可达性之外，假如一个标号被一条可到达的goto语句引用，那么我们认为此标号语句也是可到达的。
8.5 声明语句
声明语句声明一个局部常量或变量。声明语句可以在块中出现，当是不允许在嵌套语句中出现。其格式如下：
declaration-statement: local-variable-declaration ;
local-constant-declaration ;
8.5.1 局部变量声明
局部变量声明语句声明一个或多个局部变量。其格式如下：
local-variable-declaration: type variable-declarators
variable-declarators: variable-declarator variable-declarators ,
variable-declarator
variable-declarator: identifier identifier = variable-initializer
variable-initializer: expression array-initializer
被声明的局部变量的类型由声明语句引入的变量类型决定。在类型之后跟有一个变量声明符清单，其中的每一项都引入一个新的变量。
每个变量声明符包括一个标识符，一个可选的赋值符号“＝”以及一个变量初始器，它会给出变量的初始制。
局部变量的值是通过在表达式中使用简单名称获得的（请参见§7.5.2节），局部变量的值可以使用赋值语句修改（参见§错误！未找到引用源。节）。局部变量在每一次取值时必须被明确赋值（参见§错误！未找到引用源。节）。
变量的有效区间从它自身的标识符出现开始到它的声明语句所在的块结尾为止。在局部变量的有效区间内，不能再次声明另外的拥有同样名字的变量或者常量。
在一条局部变量声明语句中声明多个变量等价于多条每次只声明一个同类型局部变量的局部变量声明语句。不仅如此，变量声明语句中的变量初始器就好像在变量声明语句中插入的一条赋值语句。
请看下面的例子
void F() { int x = 1, y, z = x * 2; }
与下面语句完全相当：
void F() { int x; x = 1; int y; int z; z = x * 2; }
8.5.2 局部常量声明
一个局部常量声明语句声明一个或者多个局部常量。其格式如下：local-constant-declaration: const type constant-declarators
constant-declarators: constant-declarator constant-declarators ,
constant-declarator
constant-declarator: identifier = constant-expression
被声明的局部常量的类型由声明语句引入的常量类型决定。在类型之后跟有一个常量声明符清单，其中的每一项都引入一个新的常量。每个常量声明符包括一个标识符，一个赋值符号“＝”以及一个给出常量数值的常量表达式（参见§错误！未找到引用源。节）。
局部常量声明语句中的类型和常数表达式必须遵从有关常量成分声明的规则（参见§10.3节）。
局部常量的值是通过在表达式中使用简单名称获得的（请参见§7.5.2节）。
常量的有效区间从声明开始到它的声明语句所在的块结尾为止。在局部常量的有效区间内，不能再次声明另外的拥有同样名字的变量或者常量。
8.6 表达式语句
表达式语句对列出的表达式求值。又表达式计算出的数值，无论多少都被丢弃。其格式如下：
expression-statement: statement-expression ;
statement-expression: invocation-expression
object-creation-expression assignment post-increment-expression
post-decrement-expression pre-increment-expression
pre-decrement-expression
并不是所有表达式都允许以语句的形式出现。尤其是象x＋y和x ＝＝1这样的没有side－effect的表达式，它们只是用来求值。
表达式语句计算它列出的表达式的值，之后将程序的控制转移到表达式语句的末尾。
8.7 选择语句
选择语句依据一个控制表达式的计算值从一系列可能被执行的语句选择出要执行的语句。其格式如下：选择语句：if语句
switch语句
8.7.1 if语句
if语句依据括号中的布尔表达式选择相关语句执行。其格式如下：if-statement: if ( boolean-expression ) embedded-statement if
( boolean-expression ) embedded-statement else embedded-statement boolean-expression: expression
else分支与最近的if语句构成一个if－else对。If语句并不一定必须有else分支。这样如下所示的if语句
if (x) if (y) F(); else G();
等价于下面的语句
if (x) { if (y) { F(); } else { G(); } }
if语句按照下面的方式执行：
?求布尔表达式的值（参见§错误！未找到引用源。节）。
?如果布尔表达式为真，程序将跳转到分语句的第一个嵌套语句执行。
当程序执行到此嵌套语句的结尾，程序控制将转移到if语句的结尾。
?如果布尔表达式的值为假，而且分语句中有else分支，程序跳转到分语句的第二个嵌套语句执行。当程序执行到此嵌套语句的结尾时，程序控制将转移到if语句的结尾。
?如果布尔表达式的值为假，而且分语句中没有else分支，程序控制将转移到if语句的结尾。
假如if语句本身可到达而且它的布尔表达式值为真，那么if语句的第一个嵌套语句可到达。
假如if语句本身可到达而且它有第二个嵌套语句并且它的布尔表达式值为假，那么if语句的第二个嵌套语句可到达。
假如if语句的任意一个嵌套语句的结尾可到达，那么if语句的结尾也可到达。
另外，假如一个没有elso分支的if语句本身可到达而且它的布尔表达
式值为假，那么if语句的结尾可到达。
8.7.2 Switch 语句
switch-statement: switch ( expression ) switch-block
switch-block: { switch-sections
}
opt
switch-sections: switch-section switch-sections switch-section
switch-section: switch-labels statement-list
switch-labels: switch-label switch-labels switch-label
switch-label: case constant-expression : default :
switch语句包括关键字switch和其后的括号表达式（我们称之为switch 表达式）和switch块。Switch块包含有零个或者多个由括号包围的switch分支。每个switch分支又由一个或者多个switch标号和跟在它们后面的语句列表组成。
Switch语句的控制类型由switch表达式决定。如果switch表达式的类型为sbyte，byte，short，ushort，int，uint，long，ulong，char，string 或者枚举型，那么这就是switch语句的控制类型。否则，必须有一个用户自定义隐式转换语句（参见§错误！未找到引用源。节）把switch 表达式的类型转换为下述控制类型类型中的一种：Sbyte，byte，short，ushort，int，int，long，ulong，char，string。如果没有这样的一条转换语句或者有多条这样的转换语句存在，将产生编译错误。
每一个switch分支的常数表达式必须取得某个可被隐式转换成
switch语句控制类型的数值。如果同一个switch有两个或两个以上的switch分支的常量表达式取得相同的值，那么编译时会出错。
每一个switch语句最多只能有一个default标号分支。
Switch语句时按照如下方式执行的：
?首先计算出switch表达式的值并转换到控制类型。
?如果swtich表达式的值等于某一个switch分支的常量表达式的值，那么程序控制跳转到这个case标号后的语句列表中。
?如果switch表达式的值无法与switch语句中任何一个case常量表达式的值匹配而且switch语句中有default分支，程序控制会跳转到default 标号后的语句列表中。
?如果switch表达式的值无法与switch语句中任何一个case常量表达式的值匹配而且switch语句中没有default分支，程序控制会跳转到
switch语句的结尾。
如果一个switch语句的语句列表决定结尾是可到达的，将会产生编译错误。这就是我们所说的“无失败(no fall through)”规则。请看下面的例子
switch (i) { case 0: CaseZero(); break; case 1: CaseOne(); break; default: CaseOthers(); break; }
此switch语句是正确有效的，因为没有任意switch分支的结尾是可达的。与C和C＋＋不同，程序控制不能在相邻switch分支中转移，请看下面
的例子
switch (i) { case 0: CaseZero(); case 1: CaseZeroOrOne(); default:
CaseAny(); }
这个switch语句是错误的。当程序要在不同的switch分支间跳转时必须在跳离的switch分支中加入goto case语句或者goto default语句.请看下面的例子：
switch (i) { case 0: CaseZero(); goto case 1; case 1: CaseZeroOrOne();
goto default; default: CaseAny(); break; }
switch语句可以有多个switch分支，如下面例程所示。
switch (i) { case 0: CaseZero(); break; case 1: CaseOne(); break; case 2: default: CaseTwo(); break; }
这个switch语句时合法的。此例子并未违背“no fall through”规则因为在case2 分支和default分支属于switch语句中的同一个分支。“无失败”规则可以防止象C和C＋＋语言中的break语言被忽略的常见错误。同样因为这个规则，可以在不影响switch语句功能的情况下重重新排列其中的switch分支。如同下面的例程中，即使我们调换几个switch分支的顺序，整个switch语句的功能没有丝毫变化。
switch (i) { default: CaseAny(); break; case 1: CaseZeroOrOne(); goto default; case 0: CaseZero(); goto case 1; }
典型switch分支的语句列表往往是以break或goto case或者goto default语句作为结尾，但是也有可能某些结构使得这些语句列表的结
尾无法到达。比如，布尔表达式恒为真的while循环语句就永远无法执行到它的结尾。同样，throw或return语句总是跳转程序控制而无法执行到自身的结尾。下面的switch语句是正确的。
switch (i) { case 0: while (true) F(); case 1: throw new
ArgumentException(); case 2: return; }
一个switch语句的控制类型可以是字符串类型的，如下面例程所示：void DoCommand(string command) { switch (command.ToLower())
{ case "run": DoRun(); break; case "save": DoSave(); break; case
"quit": DoQuit(); break; default: InvalidCommand(command);
break; } }
就像§错误！未找到引用源。节中的字符串相等操作符，switch 语句是区分大小写的，只有switch表达式的值与case分支常数的值完全匹配，此case标号后的语句才会被执行。正如上面的例子所示，可以通过把switch表达式字符串和case分支常量都转换为小写的方法把此switch语句变成大小写区分的。
当一个switch语句的控制类型为字符串类型时，null可以作为case 分支常量。
Switch会可以包含有声明语句（参见§错误！未找到引用源。节）。Switch块中局部变量和常量的有效区间从它们被声明开始到switch块结束为止。
在switch块中，表达式中使用的使用的名字的含义必须始终保持一
致（参见§7.5.2.1节）。
如果switch语句是可到达的而且下面各项中的一项或多项被满足，那么某一switch分支的语句列表也是可到达的:
?switch表达式为非常数值.
?Switch表达式的值为常数且等于该switch分支的case标号常量。?Switch表达式的值为常量但不等于任何一个switch分支的case标号常量，而且此switch语句含义default分支标号分支。
?某个switch标号被一条可到达的goto case或goto default语句引用
如果满足下列各项中的一项，则我们认为switch语句的结尾是可以到达的：
?switch语句包含有一条可到达的跳出switch语句的break语句。?switch语句可到达且switch表达式的值为非常量并且switch语句中不含有default分支。
?switch语句可到达且switch表达式的值为常量但不与语句中的任一case标号常量匹配并且switch语句中不含有default分支。
8.8 重复语句
重复语句反复执行某一嵌套语句。
重复语句：while语句do语句for语句foreach语句
8.8.1 while语句
while依据其表达式的值条件执行它的嵌套语句零次或者多次。其格式如下：
while-statement: while ( boolean-expression ) embedded-statement while语句是按下面方式执行的：
?计算其自己的布尔表达式（参见§错误！未找到引用源。节）。?如果次布尔表达式值为真，程序执行while语句的嵌套语句。当程序执行到嵌套语句的结尾（或许为一条continue语句），程序将重写会到while语句的开头。
?如果布尔表达式值为假，程序跳转到while语句的结尾。
在while语句的嵌套语句当中，break语句（参见§错误！未找到引用源。节）可以使程序跳转到while语句的结尾（终止嵌套语句的执行），continue语句（参见§错误！未找到引用源。节）也可以使程序跳转到嵌套语句的结尾（以便开始下一次嵌套语句的执行）。
如果While语句是可到达的而且它的布尔表达式值不恒等于假，则while语句的嵌套语句可到达。
如果下列各项中至少有一项被满足，那么while语句的结尾为可到达的：
?存在跳出while语句的可到达的break语句。
?while语句本身可到达而且它的布尔表达式值不恒为真。
8.8.2 do语句
do语句根据其布尔表达式的值有条件的执行它的嵌套语句零次或者多次。其格式如下：
do-statement: do embedded-statement while ( boolean-expression ) ; do语句是按下面方式执行的：
?首先执行其嵌套语句
?当程序执行到嵌套语句的结尾时（有可能是因为continue语句），计算do语句布尔表达式的值（参见§错误！未找到引用源。节）。
如果其值为真，程序跳转到do语句的开头。否则，程序跳转到do 语句的结尾。
在do语句的嵌套语句当中，break语句（参见§错误！未找到引用源。节）可以使程序跳转到do语句的结尾（终止嵌套语句的执行），continue语句（参见§错误！未找到引用源。节）也可以使程序跳转到嵌套语句的结尾（以便开始下do语句的执行）。
如果While语句是可到达的而且它的布尔表达式值不恒等于假，则while语句的嵌套语句可到达。
C语言程序的设计说明
C语言程序设计 课程设计报告 专业：统计学 班级： 088131 姓名：罗钰莹 指导教师：薛思清 2015 年 01 月 26 日
目录 1...................................课程设计目的 2......................................问题需求分析 3........................................系统设计（数据结构，总体软件框架，程序模块设计） 4................................................编程实现（描述主要实现过程，主要模块设计必须用流程图或伪代码等） 4.1.................................................... 流程图 4.2.............................. .....................伪代码 4.3 ....................................................程序容 5........................................系统测试（设计测试样例，验证程序，用截图的形式表达出来） 6......................................（可选）附：部分关键源程序 7...........................................实习总结（评价对你所开发的软件，实习过程中的难题，解决过程，你的收获与经验等）
C语言程序的设计说明书
C语言程序设计说明书 一、C语言概述 1、C语言出现的历史背景： C语言是国际上广泛流行的计算机高级语言,既可用来写系统软件，也可用来写应用软件。 C语言是在B语言的基础上发展起来的，它的根源可以追溯到ALGOL 60。1960年出现的ALGOL 60是一种面向问题的高级语言，它离硬件比较远，不宜用来编写系统程序。1963年英国的剑桥大学推出了CPL (combined programming language)语言。CPL语言在ALGOL 60的基础上接近硬件一些，但规模比较大，难以实现。1967年英国剑桥大学的Matin Richards对CPL语言做了简化，推出了BCPL (basic combined programming language) 语言。1970年美国贝尔实验室的Ken Thompson 以BCPL语言为基础，又做了进一步简化，设计出了很简单的而且很接近硬件的B语言 (取BCPL的第一个字母)，并用B语言写了第一个UNIX操作系统，在PDP7上实现。1971年在PDP11/20上实现了B语言，并写了UNIX操作系统。但B语言过于简单，功能有限。 1972年至1973年间，贝尔实验室的D.M.Ritchie 在B语言的基础上设计出了C语言(取BCPL的第二个字母)。C语言既保持了BCPL和B语言的优点(精练，接近硬件)，又克服了它们的缺点(过于简单，数据无类型等)。最初的C语言只是为描述和实现UNIX操作系统提供一种工作语言而设计的。1973年，K.Thompson 和D.M.Ritchie两人合作把UNIX的90%以上用C改写，即UNIX第5版。原来的UNIX 操作系统是1969年由美国的贝尔实验室的K.Thompson和D.M.Ritchie开发成功的，是用汇编语言写的。 后来，C语言多次做了改进，但主要还是在贝尔实验室部使用。直到1975年UNIX第6版公布后，C语言的突出优点才引起人们的普遍注意。1977年出现了不依赖于具体机器的C语言编译文本《可移植C语言编译程序》，使C移植到其他机器时所需做的工作大大简化了，这也推动了UNIX操作系统迅速地在各种机器上实现。例如VAX、 AT&T等计算机系统都相继开发了UNIX。随着UNIX的日益广泛使用，C语言也迅速得到推广。C语言和UNIX可以说是一对孪生兄弟，在发展过程中相辅相成。1978年以后，C语言已先后移植到大、中、小、微型机上，已独立于UNIX和PDP了。现在C语言已风靡全世界，成为世界上应用最广泛的几种计算机语言之一。以1978年发表的UNIX第7版中的C编译程序为基础，Brian W.Kernighan和Dennis M.Ritchie (合称K&R)合著了影响深远的名著《The C Programming Language》，这本书中介绍的C语言成为后来广泛使用的C语言版本的基础，它被称为标准C。1983年，美国国家标准化协会(ANSI)根据C语言问世以来各种版本对C的发展和扩充，制定了新的标准，称为ANSI C。 ANSI C 比原来的标准C有了很大的发展。K & R在1988年修改了他们的经典著作《The C Programming Language》，按照 ANSI C 标准重新写了该书。1987年，ANSI又公布了新标准——87 ANSIC。 1990年，国际标准化组织ISO(International Standard Organization) 接受87 ANSI C为ISO C 的标准(ISO 9899—1990)。目前流行的C编译系统都是以它
c语言试题 说明语句2
若有说明语句:char c='\72';则变量c（）。 A.说明不合法，c的值不确定 B.包含2个字符 C.包含3个字符 D.包含1个字符 以下程序的输出结果是 main() { int a = 2, b =5; printf(“a=%%d,b=%%d\n”,a, b); } A.a=%2,b=%5 B.a=%%d,b=%%d C.a=%d,b=%d D.a=2,b=5 若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是（）。 A.函数调用可以出现在表达式中 B.函数调用可以作为独立的语句存在 C.函数调用可以作为一个函数的实参 D.函数调用可以作为一个函数的形参 以下语句中，不能实现回车换行的是（）。 A.fprintf(stdout,"\n"); B.fwrite("\n",1,1,stdout); C.printf("\n"); D.putchar("\n"); 下列程序的输出结果为（）。 main()
{int m=7,n=4; float a=38.4,b=6.4,x; x=m/2+n*a/b+1/2; printf("%f\n",x); } A.28.000000 B.27.500000 C.28.500000 D.27.000000 以下运算符中，优先级最高的运算符是（）。 A.== B.|| C.! D.% 已知ch是字符变量,以下不正确的赋值语句是() A.ch='b'; B.ch="b"; C.ch='\x61'+3; D.ch='\141'; 若有int w=12;，对以下程序段,描述正确的是(). while(w=0) w=w-1; A.循环是无限循环 B.循环体执行了10次 C.循环体语句执行了一次 D.循环体语句一次也不执行 以下不正确的if语句形式是（）。 A.if(x!=y) scanf("%d",&x); else scanf("%d",&y); B.if(x>y&&x!=y);
c 语言 错误提示语句
Ambiguous operators need parentheses -----------不明确的运算需要用括号括起Ambiguous symbol ''xxx'' ----------------不明确的符号 Argument list syntax error ----------------参数表语法错误 Array bounds missing ------------------丢失数组界限符 Array size toolarge -----------------数组尺寸太大 Bad character in paramenters ------------------参数中有不适当的字符 Bad file name format in include directive --------------------包含命令中文件名格式不正确 Bad ifdef directive synatax ------------------------------编译预处理ifdef有语法错Bad undef directive syntax ---------------------------编译预处理undef有语法错 Bit field too large ----------------位字段太长 Call of non-function -----------------调用未定义的函数 Call to function with no prototype ---------------调用函数时没有函数的说明Cannot modify a const object ---------------不允许修改常量对象 Case outside of switch ----------------漏掉了case 语句 Case syntax error ------------------ Case 语法错误 Code has no effect -----------------代码不可述不可能执行到 Compound statement missing{ --------------------分程序漏掉"{" Conflicting type modifiers ------------------不明确的类型说明符 Constant expression required ----------------要求常量表达式 Constant out of range in comparison -----------------在比较中常量超出范围Conversion may lose significant digits -----------------转换时会丢失意义的数字Conversion of near pointer not allowed -----------------不允许转换近指针 Could not find file ''xxx'' -----------------------找不到XXX文件 Declaration missing ; ----------------说明缺少"；" Declaration syntax error -----------------说明中出现语法错误 Default outside of switch ------------------ Default 出现在switch语句之外 Define directive needs an identifier ------------------定义编译预处理需要标识符Division by zero ------------------用零作除数 Do statement must have while ------------------ Do-while语句中缺少while部分Enum syntax error ---------------------枚举类型语法错误 Enumeration constant syntax error -----------------枚举常数语法错误 Error directive :xxx ------------------------错误的编译预处理命令 Error writing output file ---------------------写输出文件错误 Expression syntax error -----------------------表达式语法错误 Extra parameter in call ------------------------调用时出现多余错误 File name too long ----------------文件名太长 Function call missing -----------------函数调用缺少右括号 Fuction definition out of place ------------------函数定义位置错误 Fuction should return a value ------------------函数必需返回一个值 Goto statement missing label ------------------ Goto语句没有标号 Hexadecimal or octal constant too large ------------------16进制或8进制常数太大Illegal character ''x'' ------------------非法字符x
C语言声明详解
人们常说，C语言的声明太复杂了，的确，这也是C语言饱受批评的地方之一。不过，笔者认为，真正要受到批评的不是语言本身，而是那些传播者。传播者们通常都有一个共识：讲述要由浅入深。作为原则，笔者并非要反对它，毕竟笔者对C语言的学习，也经历了相同的过程。但是，由浅入深并不意味着一切从简，以偏盖全。计算机语言不同于数学理论（虽然它的确根植于数学，与数学密不可分），数学理论是一种循序渐进的过程，后面的理论以前面的理论为基础。但C语言归根说底，就是一堆语言规则而已，应该让学习者一开始就全面且详细地了解它，而不是象现在某些教材所做的那样，只说一部分，不说另一部分，以为这就是由浅入深了，实际上这是以偏盖全。 语言如此，声明作为C语言的一部分更是如此。我们最常见到的对声明的描述是这样的：存储类别类型限定词类型标识符 这种说明会给人们一种暗示：C语言的声明是静止的、死板的，什么声明都能够以这个为基础，往上一套就OK了。事实真的如此吗？说句心里话，笔者也祈祷事实真的如此，这样世界就简单多了、清静多了。但别忘了，这个世界总是让人事与愿违的。实际上，C的声明的组织形式是以嵌套为基础的，是用嵌套声明组织起来的，并非象上面所述那么死板，存储类说明符一定得放在限定词前面吗？类型说明符一定要紧贴标识符吗？不！C标准从来没有这样说过！下面来看一看C89对声明的形式是如何规定的： 声明： 声明说明符初始化声明符表opt [opt的意思是option，可选] 其中声明说明符由以下三项构成： 声明说明符： 存储类说明符声明说明符opt 类型说明符声明说明符opt 类型限定符声明说明符opt 在这里，一个声明说明符可以包含另一个声明说明符，这就是声明的嵌套，这种嵌套贯穿于整个声明之中，今天我们看来一个非常简单的声明，其实就是由多个声明嵌套组成的，例如：
C语言的9种控制语句
C语言的32个关键字和9种控制语句 C语言的关键字共有32个，根据关键字的作用，可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。 1 数据类型关键字（12个）： (1) char ：声明字符型变量或函数 (2) double ：声明双精度变量或函数 (3) enum ：声明枚举类型 (4) float：声明浮点型变量或函数 (5) int：声明整型变量或函数 (6) long ：声明长整型变量或函数 (7) short ：声明短整型变量或函数 (8) signed：声明有符号类型变量或函数 (9) struct：声明结构体变量或函数 (10) union：声明共用体（联合）数据类型 (11)unsigned：声明无符号类型变量或函数 (12) void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用） 2控制语句关键字（12个）： A循环语句 (1) for：一种循环语句(可意会不可言传） (2) do ：循环语句的循环体 (3) while ：循环语句的循环条件 (4) break：跳出当前循环 (5) continue：结束当前循环，开始下一轮循环 B条件语句 (1)if: 条件语句 (2)else ：条件语句否定分支（与if 连用） (3)goto：无条件跳转语句 C开关语句 (1)switch :用于开关语句 (2)case：开关语句分支 (3)default：开关语句中的“其他”分支 (4)D返回语句 (5)return ：子程序返回语句（可以带参数，也看不带参数） 3 存储类型关键字（4个） (1)auto ：声明自动变量一般不使用 (2)extern：声明变量是在其他文件正声明（也可以看做是引用变量） (3)register：声明积存器变量 (4)static ：声明静态变量 4 其它关键字（4个）： (1)const ：声明只读变量 (2)sizeof：计算数据类型长度 (3)typedef：用以给数据类型取别名（当然还有其他作用 (4)volatile：说明变量在程序执行中可被隐含地改变 二、C语言中的9种控制语句
c语言基础练习题解释
c语言基础练习题解释 第一章 C语言基础知识 1．1 选择题 1. 以下不是C语言的特点的是。 A、语言简洁紧凑 B、能够编制出功能复杂的程序 C、C语言可以直接对硬件操作 D、C语言移植性好 2. 下列字符序列中，不可用作C语言标识符的是。 A．abc1B．no.1 C．_123_D．_ok 3. 正确的C语言标识符是。 A．_buy_ B．2_buy C．?_buyD．buy? 4. 请选出可用作C语言用户标识符的一组标识符。 A．void B．a3_b3C．For D．2a define _123-abcDO WORDIF Case sizeof 5. 下列符号中，不属于转义字符的是。 A．\\ B．\0xAA C．\tD．\0 6. 不属于C语言关键字的是。 A．intB．breakC．whileD．character 7. 是C语言提供的合法关键字的是。 A．Float B．signed C．integer D．Char
8. 以下不能定义为用户标示符的是。 A．scanf B．Void C．_3com_ D．int 9. 一个C程序是由。 A．一个主程序和若干子程序组成 B．一个或多个函数组成 C．若干过程组成 D．若干子程序组成 10. C语言程序的基本单位是。 A．程序行B．语句C．函数 D．字符 11. 下列说法中，错误的是。 A．每个语句必须独占一行，语句的最后可以是一个分号，也可以是一个回车换行符号 B．每个函数都有一个函数头和一个函数体，主函数也不例外 C．主函数只能调用用户函数或系统函数，用户函数可以相互调用 D．程序是由若干个函数组成的，但是必须有、而且只能有一个主函数 12. 以下说法中正确的是。 A．C语言程序总是从第一个定义的函数开始执行 B．在C语言程序中，要调用的函数必须在main函数中定义