发表于：2011/11/22 15:40:37
#0楼
赋值语句
前面已经说明，要访问内存，就需要相应的地址以表明访问哪块内存，而变量是一个映射，因此变量名就相当于一个地址。对于内存的操作，在一般情况下就只有读取内存中的数值和将数值写入内存(不考虑分配和释放内存)，在C++中，为了将一数值写入某变量对应的地址所标识的内存中(出于简便，以后称变量a对应的地址为变量a的地址，而直接称变量a的地址所标识的内存为变量a)，只需先书写变量名，后接"=",再接欲写入的数字(关于数字，请参考《C++从零开始(二)》)以及分号。如下：
a = 10.0f; b = 34;
由于接的是数字，因此就可以接表达式并由编译器生成计算相应表达式所需的代码，也就可如下：
c = a / b * 120.4f;
上句编译器将会生成进行除法和乘法计算的CPU指令，在计算完毕后(也就是求得表达式a / b * 120.4f的值了后)，也会同时生成将计算结果放到变量c中去的CPU指令，这就是语句的基本作用(对于语句，在《C++从零开始(六)》中会具体说明)。
上面在书写赋值语句时，应该确保此语句之前已经将使用到的变量定义过，这样编译器才能在生成赋值用的CPU指令时查找到相应变量的地址，进而完成CPU指令的生成。如上面的a和b,就需要在书写上面语句前先书写类似下面的变量定义：
float a; long b;
直接书写变量名也是一条语句，其导致编译器生成一条读取相应变量的内容的语句。即可以如下书写：
a;
上面将生成一条读取内存的语句，即使从内存中读出来的数字没有任何应用(当然，假如编译器开了优化选项，则上面的语句将不会生成任何代码)。从这一点以及上面的c = a / b * 120.4f;语句中，都可以看出一点--变量是可以返回数字的而变量返回的数字就是按照变量的类型来解释变量对应内存中的内容所得到的数字。这句话也许不是那么轻易理解，在看过后面的类型转换一节后应该就可以理解了。
因此为了将数据写入一块内存，使用赋值语句(即等号);要读取一块内存，书写标识内存的变量名。所以就可以这样书写：a = a + 3;
假设a原来的值为1,则上面的赋值语句将a的值取出来，加上3,得到结果4,将4再写入a中去。由于C++使用"="来代表赋值语句，很轻易使人和数学中的等号混淆起来，这点应注重。
而如上的float a;语句，当还未对变量进行任何赋值操作时，a的值是什么？上帝才知道。当时的a的内容是什么(对于VC编译器，在开启了调试选项时，将会用0xCCCCCCCC填充这些未初始化内存)，就用IEEE的real*4格式来解释它并得到相应的一个数字，也就是a的值。因此应在变量定义的时候就进行赋值(但是会有性能上的影响，不过很小)，以初始化变量而防止出现莫名其妙的值，如：float a = 0.0f;.
赋值操作符
上面的a = a + 3;的意思就是让a的值增加3.在C++中，对于这种情况给出了一种简写方案，即前面的语句可以写成：a += 3;.应当注重这两条语句从逻辑上讲都是使变量a的值增3,但是它们实际是有区别的，后者可以被编译成优化的代码，因为其意思是使某一块内存的值增加一定数量，而前者是将一个数字写入到某块内存中。所以假如可能，应尽量使用后者，即a += 3;.这种语句可以让编译器进行一定的优化(但由于现在的编译器都非常智能，能够发现a = a + 3;是对一块内存的增值操作而不是一块内存的赋值操作，因此上面两条语句实际上可以认为完全相同，仅仅只具有简写的功能了)。
对于上面的情况，也可以应用在减法、乘法等二元非逻辑操作符(不是逻辑值操作符，即不能a &&= 3;)上，如：a *= 3; a -= 4; a = 34; a 》= 3;等。
除了上面的简写外，C++还提供了一种简写方式，即a++;,其逻辑上等同于a += 1;.同上，在电脑编程中，加一和减一是经常用到的，因此CPU专门提供了两条指令来进行加一和减一操作(转成汇编语言就是Inc和Dec)，但速度比直接通过加法或减法指令来执行要快得多。为此C++中也就提供了"++"和"-"操作符来对应Inc和Dec.所以a++;虽然逻辑上和a = a + 1;等效，实际由于编译器可能做出的优化处理而不同，但还是如上，由于编译器的智能化，其是有可能看出a = a + 1;可以编译成Inc指令进而即使没有使用a++;却也依然可以得到优化的代码，这样a++;将只剩下简写的意义而已。
应当注重一点，a = 3;这句语句也将返回一个数字，也就是在a被赋完值后a的值。由于其可以返回数字，按照《C++从零开始(二)》中所说，"="就属于操作符，也就可以如下书写：
c = 4 + ( a = 3 );
之所以打括号是因为"="的优先级较"+"低，而更常见和正常的应用是：c = a = 3;
应该注重上面并不是将c和a赋值为3,而是在a被赋值为3后再将a赋值给c,虽然最后结果和c、a都赋值为3是一样的，但不应该这样理解。由于a++;表示的就是a += 1;就是a = a + 1;,因此a++;也将返回一个数字。也由于这个原因，C++又提供了另一个简写方式，++a;.
假设a为1,则a++;将先返回a的值，1,然后再将a的值加一;而++a;先将a的值加一，再返回a的值，2.而a-和-a也是如此，只不过是减一罢了。
上面的变量a按照最上面的变量定义，是float类型的变量，对它使用++操作符并不能得到预想的优化，因为float类型是浮点类型，其是使用IEEE的real*4格式来表示数字的，而不是二进制原码或补码，而前面提到的Inc和Dec指令都是出于二进制的表示优点来进行快速增一和减一，所以假如对浮点类型的变量运用"++"操作符，将完全只是简写，没有任何的优化效果(当然，假如CPU提供了新的指令集，如MMX等，以对real*4格式进行快速增一和减一操作，且编译器支持相应指令集，则还是可以产生优化效果的)。
赋值操作符的返回值
在进一步了解++a和a++的区别前，先来了解何谓操作符的计算(Evaluate)。操作符就是将给定的数字做一些处理，然后返回一个数字。而操作符的计算也就是执行操作符的处理，并返回值。前面已经知道，操作符是个符号，其一侧或两侧都可以接数字，也就是再接其他操作符，而又由于赋值操作符也属于一种操作符，因此操作符的执行顺序变得相当重要。
对于a + b + c,将先执行a + b,再执行( a + b ) + c的操作。你可能觉得没什么，那么如下，假设a之前为1:
c = ( a *= 2 ) + ( a += 3 );
上句执行后a为5.而c = ( a += 3 ) + ( a *= 2 );执行后，a就是8了。那么c呢？结果可能会大大的出乎你的意料。前者的c为10,而后者的c为16.
上面说了那么多，无非只是想告诫你--在表达式中运用赋值操作符是不被推崇的。因为其不符合平常的数学表达式的习惯，且计算顺序很轻易搞混。假如有多个"++"操作符，最好还是将表达式分开，否则很轻易导致错误的计算顺序而计算错误。并且导致计算顺序混乱的还不止上面的a++就完了，为了让你更加地重视前面的红字，下面将介绍更令人火大的东西，假如你已经同意上面的红字，则下面这一节完全可以跳过，其对编程来讲可以认为根本没有任何意义
序列点(Sequence Point)和附加效果(Side Effect)
在计算c = a++时，当c的值计算(Evaluate)出来时，a的值也增加了一，a的值加一就是计算前面表达式的附加效果。有什么问题？它可能影响表达式的计算结果。
对于a = 0; b = 1; ( a *= 2 ) && ( b += 2 );,由于两个"()"优先级相同，从左向右计算，计算"*="而返回a的地址，再计算"+="而返回b的地址，最后由于a的值为0而返回逻辑假。很正常，但效率低了点。
假如"&&"左边的数字已经是0了，则不再需要计算右边的式子。同样，假如" "左边的数字已经非零了，也不需要再计算右边的数字。因为"&&"和" "都是数学上的，数学上不管先计算加号左边的值还是右边的值，结果都不会改变，因此"&&"和" "才会做刚才的解释。这也是C++保证的，既满足数学的定义，又能提供优化的途径("&&"和" "右边的数字不用计算了)。
因此上面的式子就会被解释成--假如a在自乘了2后的值为0,则b就不用再自增2了。这很明显地违反了我们的初衷，认为b无论如何都会被自增2的。但是C++却这样保证，不仅仅是因为数学的定义，还由于代码生成的优化。但是按照操作符的优先级进行计算，上面的b += 2依旧会被执行的(这也正是我们会书写上面代码的原因)。为了实现当a为0时b += 2不会被计算，C++提出了序列点的概念。
序列点是一些非凡位置，由C++强行定义(C++并未给出序列点的定义，因此不同的编译器可能给出不同的序列点定义，VC是按照C语言定义的序列点)。当在进行操作符的计算时，假如碰到序列点，则序列点处的值必须被优先计算，以保证一些非凡用途，如上面的保证当a为0时不计算b += 2,并且序列点相关的操作符(如前面的"&&"和" ")也将被计算完毕，然后才恢复正常的计算。
"&&"的左边数字的计算就是一个序列点，而" "的左边数字的计算也是。C++定义了多个序列点，包括条件语句、函数参数等条件下的表达式计算，在此，不需要具体了解有哪些序列点，只需要知道由于序列点的存在而可能导致赋值操作符的计算出乎意料。下面就来分析一个例子：
a = 0; b = 1; ( a *= 2 ) && ( b += ++a );
按照优先级的顺序，编译器发现要先计算a *= 2,再计算++a,接着"+=",最后计算"&&".然后编译器发现这个计算过程中，出现了"&&"左边的数字这个序列点，其要保证被优先计算，这样就有可能不用计算b += ++a了。所以编译器先计算"&&"的数字，通过上面的计算过程，编译器发现就要计算a *= 2才能得到"&&"左边的数字，因此将先计算a *= 2,返回a的地址，然后计算"&&"左边的数字，得a的值为0,因此就不计算b += ++a了。而不是最开始想象的由于优先级的关系先将a加一后再进行a的计算，以返回1.所以上面计算完毕后，a为0,b为1,返回0,表示逻辑假。
因此序列点的出现是为了保证一些非凡规则的出现，如上面的"&&"和" ".再考虑","操作符，其操作是计算两边的值，然后返回右边的数字，即：a, b + 3将返回b + 3的值，但是a依旧会被计算。由于","的优先级是最低的(但高于前面提到的"数字"操作符)，因此假如a = 3, 4;,那么a将为3而不是4,因为先计算"=",返回a的地址后再计算",".又：
a = 1; b = 0; b = ( a += 2 ) + ( ( a *= 2, b = a - 1 ) && ( c = a ) );
由于"&&"左边数字是一个序列点，因此先计算a *= 2, b的值，但根据","的返回值定义，其只返回右边的数字，因此不计算a *= 2而直接计算b = a – 1得0,"&&"就返回了，但是a *= 2就没有被计算而导致a的值依旧为1,这违反了","的定义。为了消除这一点(当然可能还有其他应用","的情况)，C++也将","的左边数字定为了序列点，即一定会优先执行","左边的数字以保证","的定义--计算两边的数字。所以上面就由于","左边数字这个序列点而导致a *= 2被优先执行，并导致b为1,因此由于"&&"是序列点且其左边数字非零而必须计算完右边数字后才恢复正常优先级，而计算c = a,得2,最后才恢复正常优先级顺序，执行a += 2和"+".结果就a为4,c为2,b为5.
所以前面的a = 3, 4;其实就应该是编译器先发现","这个序列点，而发现要计算","左边的值，必须先计算出a = 3,因此才先计算a = 3以至于感觉序列点似乎没有发生作用。下面的式子请自行分析，执行后a为4,但假如将其中的","换成"&&",a为2.
a = 1; b = ( a *= 2 ) + ( ( a *= 3 )， ( a -= 2 ) );
假如上面你看得很晕，没关系，因为上面的内容根本可以认为毫无意义，写在这里也只是为了进一步向你证实，在表达式中运用赋值运算符是不好的，即使它可能让你写出看起来简练的语句，但它也使代码的可维护性降低。
类型转换
在《C++从零开始(二)》中说过，数字可以是浮点数或是整型数或其他，也就是说数字是具有类型的。注重《C++从零开始(三)》中对类型的解释，类型只是说明如何解释状态，而在前面已经说过，出于方便，使用二进制数来表示状态，因此可以说类型是用于告诉编译器如何解释二进制数的。
所以，一个长整型数字是告诉编译器将得到的二进制数表示的状态按照二进制补码的格式来解释以得到一个数值，而一个单精度浮点数就是告诉编译器将得到的二进制数表示的状态按照IEEE的real*4的格式来解释以得到一个是小数的数值。很明显，同样的二进制数表示的状态，按照不同的类型进行解释将得到不同的数值，那么编译器如何知道应该使用什么类型来进行二进制数的解释？
前面已经说过，数字是一种很非凡的操作符，其没有操作数，仅仅返回由其类型而定的二进制数表示的状态(以后为了方便，将"二进制数表示的状态"称作"二进制数")。而操作符就是执行指令并返回数字，因此所有的操作符到最后一定执行的是返回一个二进制数。这点很重要，对于后面指针的理解有着重要的意义。
先看15;,这是一条语句，因为15是一个数字。所以15被认为是char类型的数字(因为其小于128,没超出char的表示范围)，将返回一个8位长的二进制数，此二进制数按照补码格式编写，为00001111.
再看15.0f,同上，其由于接了"f"这个后缀而被认为是float类型的数字，将返回一个32位长的二进制数，此二进制数按照IEEE的real*4格式编写，为1000001011100000000000000000000.
虽然上面15和15.0f的数值相等，但由于是不同的类型导致了使用不同的格式来表示，甚至连表示用的二进制数的长度都不相同。因此假如书写15.0f == 15;将返回0,表示逻辑假。但实际却返回1,为什么？
上面既然15和15.0f被表示成完全不同的两个二进制数，但我们又认为15和15.0f是相等的，但它们的二进制表示不同，怎么办？将表示15.0f的二进制数用IEEE的real*4格式解释出15这个数值，然后再将其按8位二进制补码格式编写出二进制数，再与原来的表示15的二进制数比较。
QQ病毒 腾讯QQ空间代码专题 PPT教程专题 ADSL应用面面俱到 fireworks教程专题 计算机和网络技术基础知识 校园网专题 网吧技术专题
为了实现上面的操作，C++提供了类型转换操作符--"()".其看起来和括号操作符一样，但是格式不同：(<类型名 designtimesp=31660>)<数字 designtimesp=31661>或<类型名 designtimesp=31662>(<数字 designtimesp=31663>)。
上面类型转换操作符的<类型名 designtimesp=31666>不是数字，因此其将不会被操作，而是作为一个参数来控制其如何操作后面的<数字 designtimesp=31667>.<类型名 designtimesp=31668>是一个标识符，其唯一标识一个类型，如char、float等。类型转换操作符的返回值就如其名字所示，将<数字 designtimesp=31669>按照<类型名 designtimesp=31670>标识的类型来解释，返回类型是<类型名 designtimesp=31671>的数字。因此，上面的例子我们就需要如下编写：15 == ( char )15.0f;,现在其就可以返回1,表示逻辑真了。但是即使不写( char )，前面的语句也返回1.这是编译器出于方便的缘故而帮我们在15前添加了( float )，所以依然返回1.这被称作隐式类型转换，在后面说明类的时候，还将提到它。
应该注重类型转换操作符"()"和前缀"++"、"!"、负号"-"等的优先级一样，并且是从右向左计算的，因此( char )-34;将会先计算-34的值，然后再计算( char )的值，这也正好符合人的习惯。
前面已经说明，要访问内存，就需要相应的地址以表明访问哪块内存，而变量是一个映射，因此变量名就相当于一个地址。对于内存的操作，在一般情况下就只有读取内存中的数值和将数值写入内存(不考虑分配和释放内存)，在C++中，为了将一数值写入某变量对应的地址所标识的内存中(出于简便，以后称变量a对应的地址为变量a的地址，而直接称变量a的地址所标识的内存为变量a)，只需先书写变量名，后接"=",再接欲写入的数字(关于数字，请参考《C++从零开始(二)》)以及分号。如下：
a = 10.0f; b = 34;
由于接的是数字，因此就可以接表达式并由编译器生成计算相应表达式所需的代码，也就可如下：
c = a / b * 120.4f;
上句编译器将会生成进行除法和乘法计算的CPU指令，在计算完毕后(也就是求得表达式a / b * 120.4f的值了后)，也会同时生成将计算结果放到变量c中去的CPU指令，这就是语句的基本作用(对于语句，在《C++从零开始(六)》中会具体说明)。
上面在书写赋值语句时，应该确保此语句之前已经将使用到的变量定义过，这样编译器才能在生成赋值用的CPU指令时查找到相应变量的地址，进而完成CPU指令的生成。如上面的a和b,就需要在书写上面语句前先书写类似下面的变量定义：
float a; long b;
直接书写变量名也是一条语句，其导致编译器生成一条读取相应变量的内容的语句。即可以如下书写：
a;
上面将生成一条读取内存的语句，即使从内存中读出来的数字没有任何应用(当然，假如编译器开了优化选项，则上面的语句将不会生成任何代码)。从这一点以及上面的c = a / b * 120.4f;语句中，都可以看出一点--变量是可以返回数字的而变量返回的数字就是按照变量的类型来解释变量对应内存中的内容所得到的数字。这句话也许不是那么轻易理解，在看过后面的类型转换一节后应该就可以理解了。
因此为了将数据写入一块内存，使用赋值语句(即等号);要读取一块内存，书写标识内存的变量名。所以就可以这样书写：a = a + 3;
假设a原来的值为1,则上面的赋值语句将a的值取出来，加上3,得到结果4,将4再写入a中去。由于C++使用"="来代表赋值语句，很轻易使人和数学中的等号混淆起来，这点应注重。
而如上的float a;语句，当还未对变量进行任何赋值操作时，a的值是什么？上帝才知道。当时的a的内容是什么(对于VC编译器，在开启了调试选项时，将会用0xCCCCCCCC填充这些未初始化内存)，就用IEEE的real*4格式来解释它并得到相应的一个数字，也就是a的值。因此应在变量定义的时候就进行赋值(但是会有性能上的影响，不过很小)，以初始化变量而防止出现莫名其妙的值，如：float a = 0.0f;.
赋值操作符
上面的a = a + 3;的意思就是让a的值增加3.在C++中，对于这种情况给出了一种简写方案，即前面的语句可以写成：a += 3;.应当注重这两条语句从逻辑上讲都是使变量a的值增3,但是它们实际是有区别的，后者可以被编译成优化的代码，因为其意思是使某一块内存的值增加一定数量，而前者是将一个数字写入到某块内存中。所以假如可能，应尽量使用后者，即a += 3;.这种语句可以让编译器进行一定的优化(但由于现在的编译器都非常智能，能够发现a = a + 3;是对一块内存的增值操作而不是一块内存的赋值操作，因此上面两条语句实际上可以认为完全相同，仅仅只具有简写的功能了)。
对于上面的情况，也可以应用在减法、乘法等二元非逻辑操作符(不是逻辑值操作符，即不能a &&= 3;)上，如：a *= 3; a -= 4; a = 34; a 》= 3;等。
除了上面的简写外，C++还提供了一种简写方式，即a++;,其逻辑上等同于a += 1;.同上，在电脑编程中，加一和减一是经常用到的，因此CPU专门提供了两条指令来进行加一和减一操作(转成汇编语言就是Inc和Dec)，但速度比直接通过加法或减法指令来执行要快得多。为此C++中也就提供了"++"和"-"操作符来对应Inc和Dec.所以a++;虽然逻辑上和a = a + 1;等效，实际由于编译器可能做出的优化处理而不同，但还是如上，由于编译器的智能化，其是有可能看出a = a + 1;可以编译成Inc指令进而即使没有使用a++;却也依然可以得到优化的代码，这样a++;将只剩下简写的意义而已。
应当注重一点，a = 3;这句语句也将返回一个数字，也就是在a被赋完值后a的值。由于其可以返回数字，按照《C++从零开始(二)》中所说，"="就属于操作符，也就可以如下书写：
c = 4 + ( a = 3 );
之所以打括号是因为"="的优先级较"+"低，而更常见和正常的应用是：c = a = 3;
应该注重上面并不是将c和a赋值为3,而是在a被赋值为3后再将a赋值给c,虽然最后结果和c、a都赋值为3是一样的，但不应该这样理解。由于a++;表示的就是a += 1;就是a = a + 1;,因此a++;也将返回一个数字。也由于这个原因，C++又提供了另一个简写方式，++a;.
假设a为1,则a++;将先返回a的值，1,然后再将a的值加一;而++a;先将a的值加一，再返回a的值，2.而a-和-a也是如此，只不过是减一罢了。
上面的变量a按照最上面的变量定义，是float类型的变量，对它使用++操作符并不能得到预想的优化，因为float类型是浮点类型，其是使用IEEE的real*4格式来表示数字的，而不是二进制原码或补码，而前面提到的Inc和Dec指令都是出于二进制的表示优点来进行快速增一和减一，所以假如对浮点类型的变量运用"++"操作符，将完全只是简写，没有任何的优化效果(当然，假如CPU提供了新的指令集，如MMX等，以对real*4格式进行快速增一和减一操作，且编译器支持相应指令集，则还是可以产生优化效果的)。
赋值操作符的返回值
在进一步了解++a和a++的区别前，先来了解何谓操作符的计算(Evaluate)。操作符就是将给定的数字做一些处理，然后返回一个数字。而操作符的计算也就是执行操作符的处理，并返回值。前面已经知道，操作符是个符号，其一侧或两侧都可以接数字，也就是再接其他操作符，而又由于赋值操作符也属于一种操作符，因此操作符的执行顺序变得相当重要。
对于a + b + c,将先执行a + b,再执行( a + b ) + c的操作。你可能觉得没什么，那么如下，假设a之前为1:
c = ( a *= 2 ) + ( a += 3 );
上句执行后a为5.而c = ( a += 3 ) + ( a *= 2 );执行后，a就是8了。那么c呢？结果可能会大大的出乎你的意料。前者的c为10,而后者的c为16.
上面说了那么多，无非只是想告诫你--在表达式中运用赋值操作符是不被推崇的。因为其不符合平常的数学表达式的习惯，且计算顺序很轻易搞混。假如有多个"++"操作符，最好还是将表达式分开，否则很轻易导致错误的计算顺序而计算错误。并且导致计算顺序混乱的还不止上面的a++就完了，为了让你更加地重视前面的红字，下面将介绍更令人火大的东西，假如你已经同意上面的红字，则下面这一节完全可以跳过，其对编程来讲可以认为根本没有任何意义
序列点(Sequence Point)和附加效果(Side Effect)
在计算c = a++时，当c的值计算(Evaluate)出来时，a的值也增加了一，a的值加一就是计算前面表达式的附加效果。有什么问题？它可能影响表达式的计算结果。
对于a = 0; b = 1; ( a *= 2 ) && ( b += 2 );,由于两个"()"优先级相同，从左向右计算，计算"*="而返回a的地址，再计算"+="而返回b的地址，最后由于a的值为0而返回逻辑假。很正常，但效率低了点。
假如"&&"左边的数字已经是0了，则不再需要计算右边的式子。同样，假如" "左边的数字已经非零了，也不需要再计算右边的数字。因为"&&"和" "都是数学上的，数学上不管先计算加号左边的值还是右边的值，结果都不会改变，因此"&&"和" "才会做刚才的解释。这也是C++保证的，既满足数学的定义，又能提供优化的途径("&&"和" "右边的数字不用计算了)。
因此上面的式子就会被解释成--假如a在自乘了2后的值为0,则b就不用再自增2了。这很明显地违反了我们的初衷，认为b无论如何都会被自增2的。但是C++却这样保证，不仅仅是因为数学的定义，还由于代码生成的优化。但是按照操作符的优先级进行计算，上面的b += 2依旧会被执行的(这也正是我们会书写上面代码的原因)。为了实现当a为0时b += 2不会被计算，C++提出了序列点的概念。
序列点是一些非凡位置，由C++强行定义(C++并未给出序列点的定义，因此不同的编译器可能给出不同的序列点定义，VC是按照C语言定义的序列点)。当在进行操作符的计算时，假如碰到序列点，则序列点处的值必须被优先计算，以保证一些非凡用途，如上面的保证当a为0时不计算b += 2,并且序列点相关的操作符(如前面的"&&"和" ")也将被计算完毕，然后才恢复正常的计算。
"&&"的左边数字的计算就是一个序列点，而" "的左边数字的计算也是。C++定义了多个序列点，包括条件语句、函数参数等条件下的表达式计算，在此，不需要具体了解有哪些序列点，只需要知道由于序列点的存在而可能导致赋值操作符的计算出乎意料。下面就来分析一个例子：
a = 0; b = 1; ( a *= 2 ) && ( b += ++a );
按照优先级的顺序，编译器发现要先计算a *= 2,再计算++a,接着"+=",最后计算"&&".然后编译器发现这个计算过程中，出现了"&&"左边的数字这个序列点，其要保证被优先计算，这样就有可能不用计算b += ++a了。所以编译器先计算"&&"的数字，通过上面的计算过程，编译器发现就要计算a *= 2才能得到"&&"左边的数字，因此将先计算a *= 2,返回a的地址，然后计算"&&"左边的数字，得a的值为0,因此就不计算b += ++a了。而不是最开始想象的由于优先级的关系先将a加一后再进行a的计算，以返回1.所以上面计算完毕后，a为0,b为1,返回0,表示逻辑假。
因此序列点的出现是为了保证一些非凡规则的出现，如上面的"&&"和" ".再考虑","操作符，其操作是计算两边的值，然后返回右边的数字，即：a, b + 3将返回b + 3的值，但是a依旧会被计算。由于","的优先级是最低的(但高于前面提到的"数字"操作符)，因此假如a = 3, 4;,那么a将为3而不是4,因为先计算"=",返回a的地址后再计算",".又：
a = 1; b = 0; b = ( a += 2 ) + ( ( a *= 2, b = a - 1 ) && ( c = a ) );
由于"&&"左边数字是一个序列点，因此先计算a *= 2, b的值，但根据","的返回值定义，其只返回右边的数字，因此不计算a *= 2而直接计算b = a – 1得0,"&&"就返回了，但是a *= 2就没有被计算而导致a的值依旧为1,这违反了","的定义。为了消除这一点(当然可能还有其他应用","的情况)，C++也将","的左边数字定为了序列点，即一定会优先执行","左边的数字以保证","的定义--计算两边的数字。所以上面就由于","左边数字这个序列点而导致a *= 2被优先执行，并导致b为1,因此由于"&&"是序列点且其左边数字非零而必须计算完右边数字后才恢复正常优先级，而计算c = a,得2,最后才恢复正常优先级顺序，执行a += 2和"+".结果就a为4,c为2,b为5.
所以前面的a = 3, 4;其实就应该是编译器先发现","这个序列点，而发现要计算","左边的值，必须先计算出a = 3,因此才先计算a = 3以至于感觉序列点似乎没有发生作用。下面的式子请自行分析，执行后a为4,但假如将其中的","换成"&&",a为2.
a = 1; b = ( a *= 2 ) + ( ( a *= 3 )， ( a -= 2 ) );
假如上面你看得很晕，没关系，因为上面的内容根本可以认为毫无意义，写在这里也只是为了进一步向你证实，在表达式中运用赋值运算符是不好的，即使它可能让你写出看起来简练的语句，但它也使代码的可维护性降低。
类型转换
在《C++从零开始(二)》中说过，数字可以是浮点数或是整型数或其他，也就是说数字是具有类型的。注重《C++从零开始(三)》中对类型的解释，类型只是说明如何解释状态，而在前面已经说过，出于方便，使用二进制数来表示状态，因此可以说类型是用于告诉编译器如何解释二进制数的。
所以，一个长整型数字是告诉编译器将得到的二进制数表示的状态按照二进制补码的格式来解释以得到一个数值，而一个单精度浮点数就是告诉编译器将得到的二进制数表示的状态按照IEEE的real*4的格式来解释以得到一个是小数的数值。很明显，同样的二进制数表示的状态，按照不同的类型进行解释将得到不同的数值，那么编译器如何知道应该使用什么类型来进行二进制数的解释？
前面已经说过，数字是一种很非凡的操作符，其没有操作数，仅仅返回由其类型而定的二进制数表示的状态(以后为了方便，将"二进制数表示的状态"称作"二进制数")。而操作符就是执行指令并返回数字，因此所有的操作符到最后一定执行的是返回一个二进制数。这点很重要，对于后面指针的理解有着重要的意义。
先看15;,这是一条语句，因为15是一个数字。所以15被认为是char类型的数字(因为其小于128,没超出char的表示范围)，将返回一个8位长的二进制数，此二进制数按照补码格式编写，为00001111.
再看15.0f,同上，其由于接了"f"这个后缀而被认为是float类型的数字，将返回一个32位长的二进制数，此二进制数按照IEEE的real*4格式编写，为1000001011100000000000000000000.
虽然上面15和15.0f的数值相等，但由于是不同的类型导致了使用不同的格式来表示，甚至连表示用的二进制数的长度都不相同。因此假如书写15.0f == 15;将返回0,表示逻辑假。但实际却返回1,为什么？
上面既然15和15.0f被表示成完全不同的两个二进制数，但我们又认为15和15.0f是相等的，但它们的二进制表示不同，怎么办？将表示15.0f的二进制数用IEEE的real*4格式解释出15这个数值，然后再将其按8位二进制补码格式编写出二进制数，再与原来的表示15的二进制数比较。
QQ病毒 腾讯QQ空间代码专题 PPT教程专题 ADSL应用面面俱到 fireworks教程专题 计算机和网络技术基础知识 校园网专题 网吧技术专题
为了实现上面的操作，C++提供了类型转换操作符--"()".其看起来和括号操作符一样，但是格式不同：(<类型名 designtimesp=31660>)<数字 designtimesp=31661>或<类型名 designtimesp=31662>(<数字 designtimesp=31663>)。
上面类型转换操作符的<类型名 designtimesp=31666>不是数字，因此其将不会被操作，而是作为一个参数来控制其如何操作后面的<数字 designtimesp=31667>.<类型名 designtimesp=31668>是一个标识符，其唯一标识一个类型，如char、float等。类型转换操作符的返回值就如其名字所示，将<数字 designtimesp=31669>按照<类型名 designtimesp=31670>标识的类型来解释，返回类型是<类型名 designtimesp=31671>的数字。因此，上面的例子我们就需要如下编写：15 == ( char )15.0f;,现在其就可以返回1,表示逻辑真了。但是即使不写( char )，前面的语句也返回1.这是编译器出于方便的缘故而帮我们在15前添加了( float )，所以依然返回1.这被称作隐式类型转换，在后面说明类的时候，还将提到它。
应该注重类型转换操作符"()"和前缀"++"、"!"、负号"-"等的优先级一样，并且是从右向左计算的，因此( char )-34;将会先计算-34的值，然后再计算( char )的值，这也正好符合人的习惯。
[此贴子已经被shotgun于2011/11/23 8:39:13编辑过]
