前面已经说过程序就是方法的描述，而方法的描述无外乎就是动作加动作的宾语，而这里的动作在C++中就是通过语句来表现的，而动作的宾语，也就是能够被操作的资源，但非常可惜地C++语言本身只支持一种资源——内存。由于电脑实际可以操作不止内存这一种资源，导致C++语言实际并不能作为底层硬件程序的编写语言（即使是C语言也不能），不过各编译器厂商都提供了自己的嵌入式汇编语句功能（也可能没提供或提供其它的附加语法以使得可以操作硬件），对于VC，通过使用__asm语句即可实现在C++代码中加入汇编代码来操作其他类型的硬件资源。对于此语句，本系列不做说明。

　　语句就是动作，C++中共有两种语句：单句和复合语句。复合语句是用一对大括号括起来，以在需要的地方同时放入多条单句，如：{ long a = 10; a += 34; }。而单句都是以“;”结尾的，但也可能由于在末尾要插入单句的地方用复合语句代替了而用“}”结尾，如：if( a ) { a--; a++; }。应注意大括号后就不用再写“;”了，因为其不是单句。

　　方法就是怎么做，而怎么做就是在什么样的情况下以什么样的顺序做什么样的动作。因为C++中能操作的资源只有内存，故动作也就很简单的只是关于内存内容的运算和赋值取值等，也就是前面说过的表达式。而对于“什么样的顺序”，C++强行规定只能从上朝下，从左朝右来执行单句或复合语句（不要和前面关于表达式的计算顺序搞混了，那只是在一个单句中的规则）。而最后对于“什么样的情况”，即进行条件的判断。为了不同情况下能执行不同的代码，C++定义了跳转语句来实现，其是基于CPU的运行规则来实现的，下面先来看CPU是如何执行机器代码的。

　　机器代码的运行方式

　　前面已经说过，C++中的所有代码到最后都要变成CPU能够认识的机器代码，而机器代码由于是方法的描述也就包含了动作和动作的宾语（也可能不带宾语），即机器指令和内存地址或其他硬件资源的标识，并且全部都是用二进制数表示的。很正常，这些代表机器代码的二进制数出于效率的考虑在执行时要放到内存中（实际也可以放在硬盘或其他存储设备中），则很正常地每个机器指令都能有一个地址和其相对应。

　　CPU内带一种功能和内存一样的用于暂时记录二进制数的硬件，称作寄存器，其读取速度较内存要快很多，但大小就小许多了。为了加快读取速度，寄存器被去掉了寻址电路进而一个寄存器只能存放1个32位的二进制数（对于32位电脑）。而CPU就使用其中的一个寄存器来记录当前欲运行的机器指令的位置，在此称它为指令寄存器。

　　CPU运行时，就取出指令寄存器的值，进而找到相应的内存，读取1个字节的内容，查看此8位二进制数对应的机器指令是什么，进而做相应的动作。由于不同的指令可能有不同数量的参数（即前面说的动作的宾语）需要，如乘法指令要两个参数以将它们乘起来，而取反操作只需要一个参数的参与。并且两个8位二进制数的乘法和两个16位二进制数的乘法也不相同，故不同的指令带不同的参数而形成的机器代码的长度可能不同。每次CPU执行完某条机器代码后，就将指令寄存器的内容加上此机器代码的长度以使指令寄存器指向下一条机器代码，进而重复上面的过程以实现程序的运行（这只是简单地说明，实际由于各种技术的加入，如高速缓冲等，实际的运行过程要比这复杂得多）。

　　语句的分类

　　在C++中，语句总共有6种：声明语句、定义语句、表达式语句、指令语句、预编译语句和注释语句。其中的声明语句下篇说明，预编译语句将在另文中说明，而定义语句就是前面已经见过的定义变量，后面还将说明定义函数、结构等。表达式语句则就是一个表达式直接接一个“;”，如：34;、a = 34;等，以依靠操作符的计算功能的定义而生成相应的关于内存值操作的代码。注释语句就是用于注释代码的语句，即写来给人看的，不是给编译器看的。最后的指令语句就是含有下面所述关键字的语句，即它们的用处不是操作内存，而是实现前面说的“什么样的情况”。

　　这里的声明语句、预编译语句和注释语句都不会转换成机器代码，即这三种语句不是为了操作电脑，而是其他用途，以后将详述。而定义语句也不一定会生成机器代码，只有表达式语句和指令语句一定会生成代码（不考虑编译器的优化功能）。

　　还应注意可以写空语句，即;或{}，它们不会生成任何代码，其作用仅仅只是为了保证语法上的正确，后面将看到这一点。下面说明注释语句和指令语句——跳转语句、判断语句和循环语句（实际不止这些，由于异常和模板技术的引入而增加了一些语句，将分别在说明异常和模板时说明）。

　　注释语句——//、/**/

　　注释，即用于解释的标注，即一些文字信息，用以向看源代码的人解释这段代码什么意思，因为人的认知空间和电脑的完全不同，这在以后说明如何编程时会具体讨论。要书写一段话用以注释，用“/*”和“*/”将这段话括起来，如下：

long a = 1; a += 1; /* a放的是人的个数，让人的个数加一 */ b *= a; /* b放的是人均花费，得到总的花费 */

　　上面就分别针对a += 1;和b *= a;写了两条注释语句以说明各自的语义（因为只要会C++都知道它们是一个变量的自增一和另一个变量的自乘a，但不知道意义）。上面的麻烦之处就是需要写“/*”和“*/”，有点麻烦，故C++又提供了另一种注释语句——“//”：

long a = 1; a += 1; // a放的是人的个数，让人的个数加一 b *= a; // b放的是人均花费，得到总的花费

　　上面和前面等效，其中的“//”表示从它开始，这一行后面的所有字符均看成注释，编译器将不予理会，即

long a = 1; a += 1; // a放的是人的个数，让人的个数加一 b *= a;

　　其中的b *= a;将不会被编译，因为前面的“//”已经告诉编译器，从“//”开始，这一行后面的所有字符均是注释，故编译器不会编译b *= a;。但如果

long a = 1; a += 1; /* a放的是人的个数，让人的个数加一 */ b *= a;

　　这样编译器依旧会编译b *= a;，因为“/*”和“*/”括起来的才是注释。

　　应该注意注释语句并不是语句，其不以“;”结束，其只是另一种语法以提供注释功能，就好象以后将要说明的预编译语句一样，都不是语句，都不以“;”结束，既不是单句也不是复合语句，只是出于习惯的原因依旧将它们称作语句。

 

 

 

跳转语句——goto

　　前面已经说明，源代码（在此指用C++编写的代码）中的语句依次地转变成用长度不同的二进制数表示的机器代码，然后顺序放在内存中（这种说法不准确）。如下面这段代码：

long a = 1; // 假设长度为5字节，地址为3000 a += 1; // 则其地址为3005，假设长度为4字节 b *= a; // 则其地址为3009，假设长度为6字节

　　上面的3000、3005和3009就表示上面3条语句在内存中的位置，而所谓的跳转语句，也就是将上面的3000、3005等语句的地址放到前面提过的指令寄存器中以使得CPU开始从给定的位置执行以表现出执行顺序的改变。因此，就必须有一种手段来表现语句的地址，C++对此给出了标号（Label）。

　　写一标识符，后接“:”即建立了一映射，将此标识符和其所在位置的地址绑定了起来，如下：

long a = 1; // 假设长度为5字节，地址为3000 P1: a += 1; // 则其地址为3005，假设长度为4字节 P2: b *= a; // 则其地址为3009，假设长度为6字节 goto P2;

　　上面的P1和P2就是标号，其值分别为3005和3009，而最后的goto就是跳转语句，其格式为goto <标号>;。此语句非常简单，先通过“:”定义了一个标号，然后在编写goto时使用不同的标号就能跳到不同的位置。

　　应该注意上面故意让P1和P2定义时独占一行，其实也可以不用，即：

long a = 1; P1: a += 1; P2: b *= a; goto P2;

　　因此看起来“P1:”和“P2:”好象是单独的一条定义语句，应该注意，准确地说它们应该是语句修饰符，作用是定义标号，并不是语句，即这样是错误的：

long a = 1; P1: { 　a += 1; 　P2: b *= a; 　P3: } goto P2;

　　上面的P3:将报错，因为其没有修饰任何语句。还应注意其中的P1仍然是3005，即“{}”仅仅只是其复合的作用，实际并不产生代码进而不影响语句的地址。

　　判断语句——if else、switch

　　if else 前面说过了，为了实现“什么样的情况”做“什么样的动作”，故C++非常正常地提供了条件判断语句以实现条件的不同而执行不同的代码。if else的格式为：

if(<数字>)<语句1>else<语句2> 或者 if(<数字>)<语句1> long a = 0, b = 1; P1: a++; b *= a; if( a < 10 ) goto P1; long c = b;

　　上面的代码就表示只有当a的值小于10时，才跳转到P1以重复执行，最后的效果就是c的值为10的阶乘。

　　上面的<数字>表示可以在“if”后的括号中放一数字，即表达式，而当此数字的值非零时，即逻辑真，程序跳转以执行<语句1>，如果为零，即逻辑假，则执行<语句2>。即也可如此：if( a – 10 ) goto P1;，其表示当a – 10不为零时才执行goto P1;。这和前面的效果一样，虽然最后c仍然是10的阶乘，但意义不同，代码的可读性下降，除非出于效率的考虑，不推荐如此书写代码。

　　而<语句1>和<语句2>由于是语句，也就可以放任何是语句的东西，因此也可以这样：

if( a ) long c;

　　上面可谓吃饱了撑了，在此只是为了说明<语句1>实际可以放任何是语句的东西，但由于前面已经说过，标号的定义以及注释语句和预编译语句其实都不是语句，因此下面试图当a非零时，定义标号P2和当a为零时书写注释“错误！”的意图是错误的：

if( a ) P2: 或者 if( !a ) // 错误！ a++; a++;

　　但编译器不会报错，因为前者实际是当a非零时，将a自增一；后者实际是当a为零时，将a自增一。还应注意，由于复合语句也是语句，因此：

if( a ){ 　long c = 0; 　c++; }

　　由于使用了复合语句，因此这个判断语句并不是以“;”结尾，但它依旧是一个单句，即：

if( a ) if( a < 10 ) { long c = 0; c++; } else b *= a;

　　上面虽然看起来很复杂，但依旧是一个单句，应该注意当写了一个“else”时，编译器向上寻找最近的一个“if”以和其匹配，因此上面的“else”是和“if( a < 10 )”匹配的，而不是由于上面那样的缩进书写而和“if( a )”匹配，因此b *= a;只有在a大于等于10的时候才执行，而不是想象的a为零的时候。

　　还应注意前面书写的if( a ) long c;。这里的意思并不是如果a非零，就定义变量c，这里涉及到作用域的问题，将在下篇说明。
switch 这个语句的定义或多或少地是因为实现的原因而不是和“if else”一样由于逻辑的原因。先来看它的格式：switch(<整型数字>)<语句>。

 

 

上面的<整型数字>和if语句一样，只要是一个数字就可以了，但不同地必须是整型数字（后面说明原因）。然后其后的<语句>与前相同，只要是语句就可以。在<语句>中，应该使用这样的形式：case <整型常数1>:。它在它所对应的位置定义了一个标号，即前面goto语句使用的东西，表示如果<整型数字>和<整型常数1>相等，程序就跳转到“case <整型常数1>:”所标识的位置，否则接着执行后续的语句。

long a, b = 3; switch( a + 3 ) case 2: case 3: a++; b *= a;

　　上面就表示如果a + 3等于2或3，就跳到a++;的地址，进而执行a++，否则接着执行后面的语句b *= a;。这看起来很荒谬，有什么用？一条语句当然没意义，为了能够标识多条语句，必须使用复合语句，即如下：

long a, b = 3; switch( a + 3 ) { 　b = 0; 　case 2: 　　a++; // 假设地址为3003 　case 3: 　　a--; // 假设地址为3004 　　break; 　case 1: 　　a *= a; // 假设地址为3006 } b *= a; // 假设地址为3010

　　应该注意上面的“2:”、“3:”、“1:”在这里看着都是整型的数字，但实际应该把它们理解为标号。因此，上面检查a + 3的值，如果等于1，就跳到“1:”标识的地址，即3006；如果为2，则跳转到3003的地方执行代码；如果为3，则跳到3004的位置继续执行。而上面的break;语句是特定的，其放在switch后接的语句中表示打断，使程序跳转到switch以后，对于上面就是3010以执行b *= a;。即还可如此：

switch( a ) if( a ) break;

　　由于是跳到相应位置，因此如果a为-1，则将执行a++;，然后执行a--;，再执行break;而跳到3010地址处执行b *= a;。并且，上面的b = 0;将永远不会被执行。

　　switch表示的是针对某个变量的值，其不同的取值将导致执行不同的语句，非常适合实现状态的选择。比如用1表示安全，2表示有点危险，3表示比较危险而4表示非常危险，通过书写一个switch语句就能根据某个怪物当前的状态来决定其应该做“逃跑”还是“攻击”或其他的行动以实现游戏中的人工智能。那不是很奇怪吗？上面的switch通过if语句也可以实现，为什么要专门提供一个switch语句？如果只是为了简写，那为什么不顺便提供多一些类似这种逻辑方案的简写，而仅仅只提供了一个分支选择的简写和后面将说的循环的简写？因为其是出于一种优化技术而提出的，就好象后面的循环语句一样，它们对逻辑的贡献都可以通过if语句来实现（毕竟逻辑就是判断），而它们的提出一定程度都是基于某种优化技术，不过后面的循环语句简写的成分要大一些。

　　我们给出一个数组，数组的每个元素都是4个字节大小，则对于上面的switch语句，如下：

unsigned long Addr[3]; Addr[0] = 3006; Addr[1] = 3003; Addr[2] = 3004;

　　而对于switch( a + 3 )，则使用类似的语句就可以代替：goto Addr[ a + 3 – 1 ];

　　上面就是switch的真面目，应注意上面的goto的写法是错误的，这也正是为什么会有switch语句。编译器为我们构建一个存储地址的数组，这个数组的每个元素都是一个地址，其表示的是某条语句的地址，这样，通过不同的偏移即可实现跳转到不同的位置以执行不同的语句进而表现出状态的选择。

　　现在应该了解为什么上面必须是<整型数字>了，因为这些数字将用于数组的下标或者是偏移，因此必须是整数。而<整型常数1>必须是常数，因为其由编译时期告诉编译器它现在所在位置应放在地址数组的第几个元素中。

　　了解了switch的实现后，以后在书写switch时，应尽量将各case后接的整型常数或其倍数靠拢以减小需生成的数组的大小，而无需管常数的大小。即case 1000、case1001、case 1002和case 2、case 4、case 6都只用3个元素大小的数组，而case 0、case 100、case 101就需要102个元素大小的数组。应该注意，现在的编译器都很智能，当发现如刚才的后者这种只有3个分支却要102个元素大小的数组时，编译器是有可能使用重复的if语句来代替上面数组的生成。

　　switch还提供了一个关键字——default。如下：

long a, b = 3; switch( a + 3 ) { 　case 2: 　　a++; 　　break; 　case 3: 　　a += 3; 　　break; 　default: 　　a--; } b *= a;

　　上面的“default:”表示当a + 3不为2且不为3时，则执行a--;，即default表示缺省的状况，但也可以没有，则将直接执行switch后的语句，因此这是可以的：switch( a ){}或switch( a );，只不过毫无意义罢了。

　　循环语句——for、while、do while

　　刚刚已经说明，循环语句的提供主要是出于简写目的，因为循环是方法描述中用得最多的，且算法并不复杂，进而对编译器的开发难度不是增加太多。

　　for 其格式为for(<数字1>;<数字2>;<数字3>)<语句>。其中的<语句>同上，即可接单句也可接复合语句。而<数字1>、<数字2>和<数字3>由于是数字，就是表达式，进而可以做表达式语句能做的所有的工作——操作符的计算。for语句的意思是先计算<数字1>，相当于初始化工作，然后计算<数字2>。如果<数字2>的值为零，表示逻辑假，则退出循环，执行for后面的语句，否则执行<语句>，然后计算<数字3>，相当于每次循环的例行公事，接着再计算<数字2>，并重复。上面的<语句>一般被称作循环体。

　　上面的设计是一种面向过程的设计思想，将循环体看作是一个过程，则这个过程的初始化（<数字1>）和必定执行（<数字3>）都表现出来。一个简单的循环，如下：

long a, b; for( a = 1, b = 1; a <= 10; a++ ) b *= a;

　　上面执行完后b是10的阶乘，和前面在说明if语句时举的例子相比，其要简单地多，并且可读性更好——a = 1, b = 1是初始化操作，每次循环都将a加一，这些信息是goto和if语句表现不出来的。由于前面一再强调的语句和数字的概念，因此可以如下：

long a, b = 1; for( ; b < 100; ) 　for( a = 1, b = 1; a; ++a, ++b ) 　　if( b *= a ) 　　　switch( a = b ) 　　　{ 　　　　case 1: 　　　　　a++; break; 　　　　case 2: 　　　　　for( b = 10; b; b-- ) 　　　　　{ 　　　　　　a += b * b;} 　　　　case 3: a *= a; 　　　} 　　break; }

　　上面看着很混乱，注意“case 3:”在“case 2:”后的一个for语句的循环体中，也就是说，当a = b返回1时，跳到a++;处，并由于break;的缘故而执行switch后的语句，也就是if后的语句，也就是第二个for语句的++a, ++b。当返回2时，跳到第三个for语句处开始执行，循环完后同样由break;而继续后面的执行。当返回3时，跳到a *= a;处执行，然后计算b--，接着计算b的值，检查是否非零，然后重复循环直到b的值为零，然后继续以后的执行。上面的代码并没什么意义，在这里是故意写成这么混乱以进一步说明前面提过的语句和数字的概念，如果真正执行，大致看过去也很容易知道将是一个死循环，即永远循环无法退出的循环。

 

 

还应注意C++提出了一种特殊语法，即上面的<数字1>可以不是数字，而是一变量定义语句，即可如此：for( long a = 1, b = 1; a < 10; ++a, ++b );。其中就定义了变量a和b。但是也只能接变量定义语句，而结构定义、类定义及函数定义语句将不能写在这里。这个语法的提出是更进一步地将for语句定义为记数式循环的过程，这里的变量定义语句就是用于定义此循环中充当计数器的变量（上面的a）以实现循环固定次数。

　　最后还应注意上面写的<数字1>、<数字2>和<数字3>都是可选的，即可以：for(;;);。

　　while 其格式为while(<数字>)<语句>，其中的<数字>和<语句>都同上，意思很明显，当<数字>非零时，执行<语句>，否则执行while后面的语句，这里的<语句>被称作循环体。

　　do while 其格式为do<语句>while(<数字>);。注意，在while后接了“;”以表示这个单句的结束。其中的<数字>和<语句>都同上，意思很明显，当<数字>非零时，执行<语句>，否则执行while后面的语句，这里的<语句>被称作循环体。

　　为什么C++要提供上面的三种循环语句？简写是一重要目的，但更重要的是可以提供一定的优化。for被设计成用于固定次数的循环，而while和do while都是用于条件决定的循环。对于前者，编译器就可以将前面提过的用于记数的变量映射成寄存器以优化速度，而后者就要视编译器的智能程度来决定是否能生成优化代码了。

　　while和do while的主要区别就是前者的循环体不一定会被执行，而后者的循环体一定至少会被执行一次。而出于简写的目的，C++又提出了continue和break语句。如下：

for( long i = 0; i < 10; i++ ) { if( !( i % 3 ) ) continue; if( !( i % 7 ) ) break; // 其他语句 }

　　上面当i的值能被3整除时，就不执行后面的“其他语句”，而是直接计算i++，再计算i < 10以决定是否继续循环。即continue就是终止当前这次循环的执行，开始下一次的循环。上面当i的值能被7整除时，就不执行后面的“其他语句”，而是跳出循环体，执行for后的语句。即break就是终止循环的运行，立即跳出循环体。如下：

while( --i ) do { { if( i == 10 ) if( i == 10 ) continue; continue; if( i > 20 ) if( i > 20 ) break; break; // 其他语句 // 其他语句 } }while( --i ); a = i; a = i;

　　上面的continue;执行时都将立即计算—i以判断是否继续循环，而break;执行时都将立即退出循环体进而执行后继的a = i;。

　　还应注意嵌套问题，即前面说过的else在寻找配对的if时，总是找最近的一个if，这里依旧。

long a = 0; P1: for( long i = a; i < 10; i++ ) for( long j = 0; j < 10; j++ ) { if( !( j % 3 ) ) continue; if( !( j % 7 ) ) break; if( i * j ) { a = i * j; goto P1; } // 其他语句 }

　　上面的continue;执行后，将立即计算j++，而break;执行后，将退出第二个循环（即j的循环），进而执行i++，然后继续由i < 10来决定是否继续循环。当goto P1;执行时，程序跳到上面的P1处，即执行long i = a;，进而重新开始i的循环。

　　上面那样书写goto语句是不被推荐的，因为其破坏了循环，不符合人的思维习惯。在此只是要说明，for或while、do while等都不是循环，只是它们各自的用处最后表现出来好象是循环，实际只是程序执行位置的变化。应清楚语句的实现，这样才能清楚地了解各种语句的实际作用，进而明确他人写的代码的意思。而对于自己书写代码，了解语句的实现，将有助于进行一定的优化。但当你写出即精简又执行效率高的程序时，保持其良好的可读性是一个程序员的素养，应尽量培养自己书写可读性高的代码的习惯。

　　上面的long j = 0在第一个循环的循环体内，被多次执行岂不是要多次定义？这属于变量的作用域的问题，下篇将说明。

　　本篇的内容应该是很简单的，重点只是应该理解源代码编译成机器指令后，在执行时也放在内存中，故每条语句都对应着一个地址，而通过跳转语句即可改变程序的运行顺序。下篇将对此提出一系列的概念，并重点说明类型的意义。