第4章 表达式
C++语言提供了一套丰富的运算符，并定义了这些运算符作用于内置类型的运算对象时所执行的操作。同时，当运算对象是类类型时，C++语言也允许由用户指定上述运算符的含义。本章主要介绍由语言本身定义、并用于内置类型运算对象的运算符，同时简单介绍几种标准库定义的运算符。第14章会专门介绍用户如何自定义适用于类类型的运算符。
表达式由一个或多个运算对象(operand)组成，对表达式求值将得到一个结果(result)。字面值和变量是最简单的表达式(expression)，其结果就是字面值和变量的值。把一个运算符(operator)和一个或多个运算对象组合起来可以生成较复杂的表达式。
4.1 基础
4.1.1 基本概念
C++定义了一元运算符(unary operator)和二元运算符(binary operator)。作用于一个运算对象的运算符是一元运算符，如取地址符 (&)和解引用符(*)；作用于两个运算对象的运算符是二元运算符，如相等运算符(==)和乘法运算符(*)除此之外，还有一个作用于三个运算对象的三元运算符。函数调用也是一种特殊的运算符，它对运算对象的数量没有限制。
一些符号既能作为一元运算符也能作为二元运算符。以符号*为例，作为一元运算符时执行解引用操作，作为二元运算符时执行乘法操作。一个符号到底是一元运算符还是二元运算符由它的上下文决定。对于这类符号来说，它的两种用法互不相干，完全可以当成两个不同的符号。
组合运算符和运算对象
对于含有多个运算符的复杂表达式来说，要想理解它的含义首先要理解运算符的优先级(precedence)、结合律(associativity)以及运算对象的求值顺序(order of evaluation)。例如，下面这条表达式的求值结果依赖于表达式中运算符和运算对象的组合方式：
5 + 10 * 20/2;
乘法运算符(*)是一个二元运算符，它的运算对象有4种可能：10和20、10和20/2、15和20、15和20/2。下一节将介绍如何理解这样一条表达式。
运算对象转换
在表达式求值的过程中，运算对象常常由一种类型转换成另外一种类型。例如，尽管一般的二元运算符都要求两个运算对象的类型相同，但是很多时候即使运算对象的类型不相同也没有关系，只要它们能被转换 (参见2.1.2节) 成同一种类型即可。
类型转换的规则虽然有点复杂，但大多数都合乎情理、容易理解。例如，整数能转换成浮点数，浮点数也能转换成整数，但是指针不能转换成浮点数。让人稍微有点意外的是，小整数类型(如bool、char、short等)通常会被提升(promoted)成较大的整数类型，主要是int。4.11节将详细介绍类型转换的细节。
重载运算符
C++语言定义了运算符作用于内置类型和复合类型的运算对象时所执行的操作。当运算符作用于类类型的运算对象时，用户可以自行定义其含义。因为这种自定义的过程事实上是为已存在的运算符赋予了另外一层含义，所以称之为重载运算符 (overloaded operator)。IO库的>>和<<运算符以及string对象、vector对象和迭代器使用的运算符都是重载的运算符。
我们使用重载运算符时，其包括运算对象的类型和返回值的类型，都是由该运算符定义的；但是运算对象的个数、运算符的优先级和结合律都是无法改变的。
左值和右值
C++的表达式要不然是右值(rvalue，读作“are-value”)，要不然就是左值 (lvalue,读作“ell-value”)。这两个名词是从C语言继承过来的，原本是为了帮助记忆：左值可以位于赋值语句的左侧，右值则不能。
在C++语言中，二者的区别就没那么简单了。一个左值表达式的求值结果是一个对象或者一个函数，然而以常量对象为代表的某些左值实际上不能作为赋值语句的左侧运算对象。此外，虽然某些表达式的求值结果是对象，但它们是右值而非左值。可以做一个简单的归纳：当一个对象被用作右值的时候，用的是对象的值(内容)；当对象被用作左值的时候，用的是对象的身份(在内存中的位置)。
不同的运算符对运算对象的要求各不相同，有的需要左值运算对象、有的需要右值运算对象；返回值也有差异，有的得到左值结果、有的得到右值结果。一个重要的原则（参见13.6节）是在需要右值的地方可以用左值来代替，但是不能把右值当成左值使用。当一个左值被当成右值使用时，实际使用的是它的内容（值）。到目前为止，已经有几种我们熟悉的运算符是要用到左值的。
- 赋值运算符需要一个（非常量）左值作为其左侧运算对象，得到的结果也仍然是一个左值。
- 取地址符（参见2.3.2节）作用于一个左值运算对象，返回一个指向该运算对象的指针，这个指针是一个右值。
- 内置解引用运算符、下标运算符（参见2.3.2节；参见3.5.2节）、迭代器解引用运算符、string和vector的下标运算符（参见3.4.1节；参见3.2.3节；参见3.3.3节）的求值结果都是左值。
- 内置类型和迭代器的递增递减运算符（参见1.4.1节；参见3.4.1节）作用于左值运算对象，其前置版本所得的结果也是左值。
接下来在介绍运算符的时候，我们将会注明该运算符的运算对象是否必须是左值以及其求值结果是否是左值。
使用关键字decltype（参见2.5.3节）的时候，左值和右值也有所不同。如果表达式的求值结果是左值，decltype作用于该表达式（不是变量）得到一个引用类型。举个例子，假设p的类型是int*，因为解引用运算符生成左值，所以decltype(*p)的结果是int&。另一方面，因为取地址运算符生成右值，所以decltype(&p)的结果是int**。
4.1.2 优先级与结合律
复合表达式(compound expression)是指含有两个或多个运算符的表达式。求复合表达式的值需要首先将运算符和运算对象合理地组合在一起，优先级与结合律决定了运算对象组合的方式。也就是说，它们决定了表达式中每个运算符对应的运算对象来自表达式的哪一部分。表达式中的括号无视上述规则，程序员可以使用括号将表达式的某个局部括起来使其得到优先运算。
一般来说，表达式最终的值依赖于其子表达式的组合方式。高优先级运算符的运算对象要比低优先级运算符的运算对象更为紧密地组合在一起。如果优先级相同，则其组合规则由结合律确定。例如，乘法和除法的优先级相同且都高于加法的优先级。因此，乘法和除法的运算对象会首先组合在一起，然后才能轮到加法和减法的运算对象。算术运算符满足左结合律，意味着如果运算符的优先级相同，将按照从左向右的顺序组合运算对象:
- 根据运算符的优先级，表达式3+4*5的值是23，不是35。
- 根据运算符的结合律，表达式20-15-3的值是2，不是8。
括号无视优先级与结合律
括号无视普通的组合规则，表达式中括号括起来的部分被当成一个单元来求值，然后再与其他部分一起按照优先级组合。
优先级与结合律有何影响
由前面的例子可以看出，优先级会影响程序的正确性，这一点在3.5.3节介绍的解引用和指针运算种也有所体现：
int ia[] = {0,2,4,6,8};
int last = *(ia + 4); //把last初始化成8，也就是ia[4]的值
last = *ia + 4; //last = 4，等价于ia[0] + 4
如果想访问ia+4位置的元素，那么加法运算两端的括号必不可少。一旦去掉这对括号，*ia就会首先组合在一起，然后4再与*ia的值相加。
结合律对表达式产生影响的一个典型示例是输入输出运算，4.8节将要介绍IO相关的运算符满足左结合律。这一规则意味着我们可以把几个IO 运算组合在一条表达式当中：
cin >> v1 >> v2; //先读入v1，再读入v2
4.12节罗列出了全部的运算符，并用双横线将它们分割成若干组。同一组内的运算符优先级相同，组的位置越靠前组内的运算符优先级越高。例如，前置递增运算符和解引用运算符的优先级相同并且都比算术运算符的优先级高。表中同样列出了每个运算符在哪一页有详细的描述，有些运算符之前已经使用过了，大多数运算符的细节将在本章剩余部分逐一介绍，还有几个运算符将在后面的内容中提及。
4.1.3 求值顺序
优先级规定了运算对象的组合方式，但是没有说明运算对象按照什么顺序求值。在大多数情况下，不会明确指定求值的顺序。对于如下的表达式
int i = f1() * f2();
我们知道f1和f2一定会在执行乘法之前被调用，因为毕竟相乘的是这两个函数的返回值。但是我们无法知道到底f1在f2之前调用还是f2在f1之前调用。
对于那些没有指定执行顺序的运算符来说，如果表达式指向并修改了同一个对象，将会引发错误并产生未定义的行为(参见2.1.2节)。举个简单的例子，<<运算符没有明确规定何时以及如何对运算对象求值，因此下面的输出表达式是未定义的：
int i = 0;
cout << i << " " << ++i << endl; //未定义的
因为程序是未定义的，所以我们无法推断它的行为。编译器可能先求++i的值再求i的值，此时输出结果是1 1；也可能先求i的值再求++i的值，输出结果是0 1；甚至编译器还可能做完全不同的操作。因为此表达式的行为不可预知，因此不论编译器生成什么样的代码程序都是错误的。
有4种运算符明确规定了运算对象的求值顺序。第一种是3.2.3节提到的逻辑与(&&)运算符，它规定先求左侧运算对象的值，只有当左侧运算对象的值为真时才继续求右侧运算对象的值。另外三种分别是逻辑或(||)运算符(参见4.3节)、条件(?:)运算符(参见4.7节)和逗号(,)运算符(参见4.10节)。
求值顺序、优先级、结合律
运算对象的求值顺序与优先级和结合律无关，在一条形如f()+g()*h()+j()的表达式中：
- 优先级规定，g()的返回值和h()的返回值相乘。
- 结合律规定，f()的返回值先与g()和h()的乘积相加，所得结果再与j()的返回值相加。
- 对于这些函数的调用顺序没有明确规定。
如果 f、g、h 和 j 是无关函数，它们既不会改变同一对象的状态也不执行IO任务，那么函数的调用顺序不受限制。反之，如果其中某几个函数影响同一对象，则它是一条错误的表达式，将产生未定义的行为。
建议：处理复合表达式
以下两条经验准则对书写复合表达式有益：
- 拿不准的时候最好用括号来强制让表达式的组合关系符合程序逻辑的要求。
- 如果改变了某个运算对象的值，在表达式的其他地方不要再使用这个运算对象。
第2条规则有一个重要例外，当改变运算对象的子表达式本身就是另外一个子表达式的运算对象时该规则无效。例如，在表达式*++iter中，递增运算符改变iter的值，iter（已经改变）的值又是解引用运算符的运算对象。此时（或类似的情况下），求值的顺序不会成为问题，因为递增运算（即改变运算对象的子表达式）必须先求值，然后才轮到解引用运算。显然，这是一种很常见的用法，不会造成什么问题。
4.2 算术运算符
表4.1（以及后面章节的运算符表）按照运算符的优先级将其分组。一元运算符的优先级最高，接下来是乘法和除法，优先级最低的是加法和减法。优先级高的运算符比优先级低的运算符组合得更紧密。上面的所有运算符都满足左结合律，意味着当优先级相同时按照从左向右的顺序进行组合。
除非另做特殊说明，算术运算符都能作用于任意算术类型(参见2.1.1节)以及任意能转换为算术类型的类型。算术运算符的运算对象和求值结果都是右值。如4.11节描述的那样，在表达式求值之前，小整数类型的运算对象被提升成较大的整数类型，所有运算对象最终会转换成同一类型。
一元正号运算符、加法运算符和减法运算符都能作用于指针。3.5.3节已经介绍过二元加法和减法运算符作用于指针的情况。当一元正号运算符作用于一个指针或者算术值时，返回运算对象值的一个(提升后的)副本。
一元负号运算符对运算对象值取负后，返回其（提升后的）副本：
int i = 1024;
int k = -i; //k是-1024
bool b = true;
bool b2 = -b; //b2是true！
在2.1.1节，我们指出布尔值不应该参与运算，-b就是一个很好的例子。
对大多数运算符来说，布尔类型的运算对象将被提升为int类型。如上所示，布尔变量b的值为真，参与运算时将被提升成整数值1（参见2.1.2节），对它求负后的结果时-1。将-1再转换回布尔值并将其作为b2的初始值，显然这个初始值不等于0，转换成布尔值后应该为1。所以，b2的值是真！
提示：溢出和其他算术运算异常
算术表达式有可能产生未定义的结果。一部分原因是数学性质本身：例如除数是0的情况；另外一部分则源于计算机的特点：例如溢出，当计算的结果超出该类型所能表示的范围时就会产生溢出。
假设某个机器的short类型占16位，则最大的short数值时32767。在这样一台机器上，下面的复合赋值语句将产生溢出：
short short_value = 32767; short_value += 1; //该计算导致溢出 cout << "short_value:" << short_value << endl;给short_value赋值的语句是未定义的，这是因为表示一个带符号数32768需要17位，但是short类型只有16位。很多系统在编译和运行时都不报溢出错误，像其他未定义的行为一样，溢出的结果是不可预知的。在我们的系统中，程序的输出结果是：
short_value: -32768该值发生了“环绕(wrapped around)”，符号位本来是0，由于溢出被改成了1，于是结果变成一个负值。在别的系统中也许会有其他结果，程序的行为可能不同甚至直接崩溃。
当作用于算术类型的对象时，算术运算符+、-、*、/的含义分别是加法、减法、乘法和除法。整数相除结果还是整数，也就是说，如果商含有小数部分，直接弃除:
int ival1 = 21/6; //ival1是3，结果进行了删节，余数被抛弃掉了
int ival2 = 21/7; //ival2是3，没有余数，结果是整数值
运算符%俗称“取余”或“取模”运算符，负责计算两个整数相除所得的余数，参与取余运算的运算对象必须是整数类型：
int ival = 42;
double dval = 3.14;
ival % 12; //正确：结果是6
ival % dval; //错误：运算对象是浮点类型
在除法运算中，如果两个运算对象的符号相同则商为正(如果不为0的话)，否则商为负。C++语言的早期版本允许结果为负值的商向上或向下取整，C++11 新标准则规定商一律向0取整(即直接切除小数部分)。
根据取余运算的定义，如果m和n是整数且n非0，则表达式(m/n)*n+m%n的求值结果与m相等。隐含的意思是，如果m%n不等于0，则它的符号和m相同。C++语言的早期版本允许m%n的符号匹配n的符号，而且商向负无穷一侧取整，这一方式在新标准中已经被禁止使用了。除了-m导致溢出的特殊情况，其他时候(-m)/n 和 m/(-n)都等于-(m/n)，m%(-n)等于m%n，(-m)%n等于-(m%n)。具体示例如下：
21 % 6; /*结果是3*/ 21/6; /*结果是3*/
21 % 7; /*结果是0*/ 21/7; /*结果是3*/
-21 % -8;/*结果是-5*/ -21/-8; /*结果是2*/
21 % -5;/*结果是1*/ 21/-5; /*结果是-4*/
4.3 逻辑和关系运算符
关系运算符作用于算术类型或指针类型，逻辑运算符作用于任意能转换成布尔值的类型。逻辑运算符和关系运算符的返回值都是布尔类型。值为0的运算对象(算术类型或指针类型)表示假，否则表示真。对于这两类运算符来说，运算对象和求值结果都是右值。
逻辑与和逻辑或运算符
对于逻辑与运算符(&&)来说，当且仅当两个运算对象都为真时结果为真；对于逻辑或运算符(||)来说，只要两个运算对象中的一个为真结果就为真。
逻辑与运算符和逻辑或运算符都是先求左侧运算对象的值再求右侧运算对象的值，当且仅当左侧运算对象无法确定表达式的结果时才会计算右侧运算对象的值。这种策略称为短路求值(short-circuit evaluation)。
- 对于逻辑与运算符来说，当且仅当左侧运算对象为真时才对右侧运算对象求值。
- 对于逻辑或运算符来说，当且仅当左侧运算对象为假时才对右侧运算对象求值。
逻辑非运算符
逻辑非运算符（!）将运算对象的值取反后返回。下面举一个例子，假设vec是一个整数类型的vector对象，可以使用逻辑非运算符将empty函数的返回值取反从而检查vec是否含有元素：
//输出vec的首元素（如果有的话）
if(!vec.empty())
cout << vec[0];
关系运算符
关系运算符比较运算对象的大小关系并返回布尔值。关系运算符都满足左结合律。
因为关系运算符的求值结果是布尔值，所以将几个关系运算符连写在一起会产生意想不到的结果：
if(i < j < k) //若k大于1则为真！
要想实现我们的目的，其实应该使用下面的表达式：
if(i < j && j < k)
相等性测试与布尔字面值
如果想测试一个算术对象或指针对象的真值，最直接的办法就是将其作为if语句的条件：
if(val) {} //如果val是任意的非0值，条件为真
if(!val) {} //如果val是0，条件为真
有时会试图将上面的真值测试写成如下形式：
if(val == true) { /* ... */} //只有当val等于1时条件才为真！
但是这种写法存在两个问题：首先，与之前的代码相比，上面这种写法较长而且不太直接；更重要的一是点，如果val不是布尔值，这样的比较就失去了原本的意义。
如果val不是布尔值，则代码可以改写成如下形式：
if(val == 1) {/* ... */}
进行比较运算时除非比较的对象是布尔类型，否则不要使用布尔字面值true和false作为运算对象。
4.4 赋值运算符
赋值运算符的左侧运算对象必须是一个可修改的左值。如果给定
int i = 0, j = 0, k = 0; //初始化而非赋值
const int ci = i; //初始化而非赋值
则下面的赋值语句都是非法的：
1024 = k; //错误：字面值是右值
i + j = k; //错误：算术表达式是右值
ci = k; //错误：ci是常量（不可修改的）左值
赋值运算的结果是它的左侧运算对象，并且是一个左值。相应的，结果的类型就是左侧运算对象的类型。如果赋值运算符的左右两个运算对象类型不同，则右侧运算对象将转换成左侧运算对象的类型：
k = 0; //结果：类型是int，值是0
k = 3.14159; //结果：类型是int，值是3
C++11新标准允许使用花括号括起来的初始值列表（参见2.2.1节）作为赋值语句的右侧运算对象：
k = {3.14}; //错误：窄化转换
vector<int> vi; //初始为空
vi = {0,1,2,3,4,5,6,7,8,9}; //vi现在含有10个元素了，值从0到9
如果左侧运算对象是内置类型，那么初始值列表最多只能包含一个值，而且该值即使转换的话其所占空间也不应该大于目标类型的空间（参见2.2.1节）。
对于类类型来说，赋值运算的细节由类本身决定。对于vector来说，vector模板重载了赋值运算符并且可以接收初始值列表，当赋值发生时用右侧运算对象的元素替换左侧运算对象的元素。
无论左侧运算对象的类型是什么，初始值列表都可以为空。此时，编译器创建一个值初始化（参见3.3.1节）的临时量并将其赋给左侧运算对象。
赋值运算满足右结合律
赋值运算符满足右结合律，这一点与其他二元运算符不太一样：
int ival, jval;
ival = jval = 0; //正确：都被赋值为0
因为赋值运算符满足右结合律，所以靠右的赋值运算jval=0作为靠左的赋值运算符的右侧运算对象。又因为赋值运算返回的是其左侧运算对象，所以靠右的赋值运算的结果(即jval)被赋给了ival。
对于多重赋值语句中的每一个对象，它的类型或者与右边对象的类型相同、或者可由右边对象的类型转换得到(参见4.11节)：
int ival, *pval;
ival = pval = 0; //错误：不能把指针的值赋给int
string s1, s2;
s1 = s2 = "OK"; //字符串字面值"OK"转换成string对象
因为ival和pval的类型不同，而且pval的类型(int*)无法转换成ival的类型(int)，所以尽管0这个值能赋给任何对象，但是第一条赋值语句仍然是非法的。
与之相反，第二条赋值语句是合法的。这是因为字符串字面值可以转换成string对象并赋给s2，而s2和s1的类型相同，所以s2的值可以继续赋给s1。
赋值运算优先级较低
赋值语句经常会出现在条件当中。因为赋值运算的优先级相对较低，所以通常需要给赋值部分加上括号使其符合我们的原意。下面这个循环说明了把赋值语句放在条件当中有什么用处，它的目的是反复调用一个函数直到返回期望的值 (比如42)为止:
//这是一种形式繁琐、容易出错的写法
int i = get_value(); //得到第一个值
while(i != 42){
//其他处理......
i = get_value(); //得到剩下的值
}
在这段代码中，首先调用get_value 函数得到一个值，然后循环部分使用该值作为条件。在循环体内部，最后一条语句会再次调用get_value 函数并不断重复循环。可以将上述代码以更简单直接的形式表达出来:
int i ;
while((i = get_value()) != 42){
//其他处理...
}
这个版本的while条件更容易表达我们的真实意图:不断循环读取数据直至遇到42为止。其处理过程是首先将 get_value 函数的返回值赋给 i，然后比较i和42是否相等。
如果不加括号的话含义会有很大变化，比较运算符!=的运算对象将是get_value函数的返回值及 42，比较的结果不论真假将以布尔值的形式赋值给i，这显然不是我们期望的结果。
因为赋值运算符的优先级低于关系运算符的优先级，所以在条件语句中，赋值部分通常应该加上括号。
切勿混淆相等运算符和赋值运算符
C++语言允许用赋值运算作为条件，但是这一特性可能带来意想不到的结果：
if(i = j)
此时，if语句的条件部分把j的值赋给i，然后检查赋值的结果是否为真。如果j不为0，条件将为真。然而程序员的初衷很可能是想判断i和j是否相等:
if(i == j)
复合赋值运算符
我们经常需要对对象施以某种运算，然后把计算的结果再赋给该对象。这种操作不仅对加法来说很常见，而且也常常应用于其他算术运算符或者4.8节将要介绍的位运算符。每种运算符都有相应的复合赋值形式：
+= -= *= /= %= //算术运算符
<<= >>= &= ^= |= //位运算符，参见4.8节
任何一种复合运算符都完全等价于
a = a op b;
唯一的区别是左侧运算对象的求值次数：使用复合运算符只求值一次，使用普通的运算符则求值两次。这两次包括：一次是作为右边子表达式的一部分求值，另一次是作为赋值运算的左侧运算对象求值。其实在很多地方，这种区别除了对程序性能有些许影响外几乎可以忽略不计。
4.5 递增和递减运算符
递增运算符(++)和递减运算符(--)为对象的加1和减1操作提供了一种简洁的书写形式。这两个运算符还可应用于迭代器，因为很多迭代器本身不支持算术运算，所以此时递增和递减运算符除了书写简洁外还是必须的。
递增和递减运算符有两种形式：前置版本和后置版本。到目前为止，本书使用的都是前置版本，这种形式的运算符首先将运算对象加1(或减 1)，然后将改变后的对象作为求值结果。后置版本也会将运算对象加1(或减1)，但是求值结果是运算对象改变之前那个值的副本:
int i = 0,j;
j = ++i; //j = 1, i = 1：前置版本得到递增之后的值
j = i++; //j = 1, i = 2：后置版本得到递增之前的值
这两种运算符必须作用于左值运算对象。前置版本将对象本身作为左值返回，后置版本则将对象原始值的副本作为右值返回。
建议：除非必须，否则不用递增递减运算符的后置版本
有C语言背景的读者可能对优先使用前置版本递增运算符有所疑问，其实原因非常简单：前置版本的递增运算符避免了不必要的工作，它把值加1后直接返回改变了的运算对象。与之相比，后置版本需要将原始值存储下来以便于返回这个未修改的内容。如果我们不需要修改前的值，那么后置版本的操作就是一种浪费。
对于整数和指针类型来说，编译器可能对这种额外的工作进行一定的优化；但是对于相对复杂的迭代器类型，这种额外的工作就消耗巨大了。建议养成使用前置版本的习惯，这样不仅不需要担心性能的问题，而且更重要的是写出的代码会更符合编程的初衷
在一条语句中混用解引用和递增运算符
如果我们想在一条复合表达式中既将变量加1或减1又能使用它原来的值，这时就可以使用递增和递减运算符的后置版本。
举个例子，可以使用后置的递增运算符来控制循环输出一个 vector 对象内容直至遇到(但不包括)第一个负值为止:
auto pbeg = v.begin();
//输出元素直至遇到第一个负值为止
while(pbeg != v.end() && *pbeg >= 0)
cout << *pbeg++ << endl; //输出当前值并将pbeg向前移动一个元素
后置递增运算符的优先级高于解引用运算符，因此*pbeg++等价于*(pbeg++)。pbeg++把pbeg的值加1，然后返回pbeg的初始值的副本作为其求值结果，此时解引用运算符的运算对象是pbeg未增加之前的值。最终，这条语句输出pbeg开始时指向的那个元素，并将指针向前移动一个位置。
这种用法完全是基于一个事实，即后置递增运算符返回初始的未加1的值。如果返回的是加1之后的值，解引用该值将产生错误的结果。不但无法输出第一个元素，而且更糟糕的是如果序列中没有负值，程序将可能试图解引用一个根本不存在的元素。
运算对象可按任意顺序求值
大多数运算符都没有规定运算对象的求值顺序(参见4.1.3节)，这在一般情况下不会有什么影响。然而，如果一条子表达式改变了某个运算对象的值，另一条子表达式又要使用该值的话，运算对象的求值顺序就很关键了。因为递增运算符和递减运算符会改变运算对象的值，所以要提防在复合表达式中错用这两个运算符。
为了说明这一问题，我们将重写3.4.1节的程序，该程序使用 for 循环将输入的第一个单词改成大写形式：
for(auto it = s.begin(); it != s.end() && !isspace(*it); ++it)
*it = toupper(*it); //将当前字符改成大写形式
在上述程序中，我们把解引用it和递增it两项任务分开来完成。如果用一个看似等价的while循环进行代替
//该循环的行为是未定义的！
while(beg != s.end() && !isspace(*beg))
*beg = toupper(*beg++); //错误：该赋值语句未定义
将产生未定义的行为。问题在于：赋值运算符左右两端的运算对象都用到了beg，并且右侧的运算对象还改变了beg的值，所以该赋值语句是未定义的。编译器可能按照下面的任意一种思路处理该表达式:
*beg = toupper(*beg); //如果先求左侧的值
*(beg + 1) = toupper(*beg); //如果先求右侧的值
也可能采取别的什么方式处理它。
4.6 成员访问运算符
点运算符(参见1.5.2节)和箭头运算符(参见3.4.1节)都可用于访问成员，其中，点运算符获取类对象的一个成员；箭头运算符与点运算符有关，表达式ptr->mem等价于(*ptr).mem：
string s1 = "a string", *p = &s1;
auto n = s1.size(); //运行sring对象s1的size成员
n = (*p).size(); //运行p所指对象的size成员
n = p->size(); //等价于(*p).size()
因为解引用运算符的优先级低于点运算符，所以执行解引用运算的子表达式两端必须加上括号。如果没加括号，代码的含义就大不相同了：
//运行p的size成员，然后解引用size的结果
*p.size(); //错误：p是一个指针，它没有名为size的成员
这条表达式试图访问对象p的 size 成员，但是p本身是一个指针且不包含任何成员，所以上述语句无法通过编译。
箭头运算符作用于一个指针类型的运算对象，结果是一个左值。点运算符分成两种情况：如果成员所属的对象是左值，那么结果是左值；反之，如果成员所属的对象是右值，那么结果是右值。
4.7 条件运算符
条件运算符(?
标签：运算,对象,C++,运算符,int,类型,Primer,表达式 From： https://www.cnblogs.com/LingFengJ/p/16944448.html