表达式是运算对象及运算符组成的式子，表达式求值将得到一个结果，单独的变量或者字面值也算表达式，结果是其本身。
运算符分为：一元运算符、二元运算符、三元运算符。一元即一个作用对象，二元两个作用对象，以此类推。
函数调用是一种特殊的运算符（此运算符无作用对象数量限制）
它的运算形式为：
primary-expression ( expression-list )
对于expression-list来说，其数量不限，因此说函数调用运算符对运算对象的数量没有限制。
左值和右值：这两个名词是从C语言中继承得到的，在C++中，当一个对象被用作右值时，使用的是它的值（内容），当对象被用作左值的时候，用的是它的身份（在内存中的位置）。通俗来理解的话，例如
int a=5;//这句代码声明定义了一个int变量，变量值为5，其执行的动作是在内存中划出地址为0x7fff0444—0x7fff0447这4个字节来存储int变量a，并且存储了一个二进制的5（101）
当a被用作右值时，例如
int b=a;//这里a放在右侧，使用了a的右值，即a的值5，因此b=5。
而当给变量a赋值时，形如
a=7;//这时a放在左侧，被用作左值，使用的不再是它的值了，使用的是它的身份，即使用这个地址0x7fff0444—0x7fff0447。
以上int大小和内存地址都是为说明而假定的。
不同的运算符在表达式中的行为表现和返回值各不相同，有的要求左侧运算对象，有的要求右侧运算对象，例如取地址符&，要求右侧运算对象，即对象在右边：&a;（取变量a的地址），而后置递增++则要求运算对象在左边：p++。返回值也有差异，有的返回左值，有的返回右值。哪些返回左值，哪些返回右值，需要自己留心一下，大部分返回的都是右值。
左值可以当左值用，也可以当右值用，但是右值只能用作右值。
运算符不仅要求左侧或右侧运算对象，也会要求左值对象或者右值对象，比如赋值运算符“=”，它的要求是左侧必须是左值，右侧左值和右值皆可，运算完毕后返回一个左值。
复合表达式则是含有多个运算符的组合，在含有多个运算符和运算对象时，具体要视结合情况、优先级以及先后顺序综合而定。
这三个名词之间并没有关系，优先级不影响结合，结合律也与求值顺序无关。
优先级是在复合表达式中存在多个运算符时，哪个部分先组合。
而结合律是该运算符是将左侧还是右侧视为一个整体，注意是视为一个整体，不是决定求值顺序。
优先级和结合律共同决定运算对象的组合方式，也即它们决定表达式中每个运算符对应的运算对象怎么组合。
而求值顺序则是同一个运算符作用的2个或多个对象到底哪个先求值。例如g() * f()，g()和f()的返回值相乘，但是先调用g()还是先调用f()这是求值顺序的问题，大多数运算符对这个并没有规定。
只有4个运算符规定了求值的次序：
1. 逻辑与&&，先求左侧对象，左侧为真，再求右侧
2. 逻辑或 || ,先求左侧对象，左侧为假，再求右侧
3. 条件运算符 ? :
4. 逗号运算符 ,
逗号运算符具有从左向右的关联性。 由逗号分隔的两个表达式将从左向右进行计算。
在某些上下文（如函数参数列表）中，逗号可用作分隔符。 不要将该逗号用作分隔符与将其用作运算符的情况混淆；这两种用法完全不同。
额外说明一点：当优先级相同时，有些表达式求值顺序不一定，此时产生的结果也就不确定了，对于这种情况一定要予以避免。
优先级并没有规定运算对象的求值顺序，对于表达式行为不可预知的程序，无论编译器生成什么代码，程序都是错误的。
例如对几个函数进行运算：g( )*f( )/g( )，当f( )和g( )同时对一个全局变量作出改变时，就有可能导致不确定的结果。
算术运算符的运算对象和求值结果都是右值;
赋值运算符的结果是左侧对象，即返回左侧对象，且是个左值，另外，赋值运算符是右结合，从右往左运算。
递增和递减运算符有前置和后置两个版本，后置版本优先级较高。
前置版本对对象作出改变后，返回改变后的对象本身，是一个左值。而后置版本则是改变对象后，返回对象改变前的副本，是一个右值。
在实际使用当中，除非有明确的需求，否则尽量使用前置。例如for循环的头部，for(int i=0;i<1000;++i)，这里一定不要用后置版本的递增运算。因为这里后置版本需要将原始值存储下来以便返回修改之前的内容，但在循环这里并没有使用，造成浪费，在循环特别大的时候，或者某些复杂的迭代器类型，这种额外的消耗是非常大的。使用后置版本是很糟糕的代码，因此能使用前置时一定要用前置。
位运算符是一种专门用于整型的运算符，即只能用于带符号或无符号的char,short,int与long类型。不能用于指针或者double类型，另外当位运算符用于“小整型”时，会进行提升操作，即char,short类型会被提升成int类型。
sizeof运算符返回一条表达式或一个类型名字所占的字节数。sizeof是右结合的，返回类型是size_t 。
该运算符的运算形式有2种
sizeof (type)
sizeof expr
sizeof并不会对其后的运算对象进行计算，例如，其后如果是一个不合法的指针，不会对该指针进行运算（解引用），因为sizeof运算符不解引用也能获取所指对象的类型。
对数组执行sizeof运算，得到的是整个数组的大小，不会像大多数情况那样将数组名转化为指针。
对string类型或vector类型的对象直接执行sizeof运算，则返回的是固定的大小，而不是所有元素所占空间总和的大小，要计算string类型或vector类型的对象大小需要使用其自带的size方法与元素类型的乘积来计算。如下：
#include <iostream> #include <vector> int main() { std::vector<int> v = {1, 2, 3, 4, 5}; auto n1 = sizeof (* v.begin()); //使用迭代器获取单个元素大小 auto n2 = v.size(); //获取总元素个数 std::cout << n1 * n2; //计算实际大小 return 0; }
最后，sizeof返回的值是一个常量表达式。
C++11的类型转换有显式和隐式之分，也有旧式和新式之分。
显式转换就是明确指出将某个类型转换到另一种类型，转换的前提条件是两种类型之间可以相互转换，比如int转换为double，而指针和int就无法相互转换
隐式转换则是一个表达式中含有不同类型的对象，计算时，程序将自动的去转换。
新式转换是使用命名的强制类型转换，目前有static_cast、const_cast和reinterpret_cast。
static_cast可以在不同类型之间转换，也即改变表达式的类型。const_cast只能用于const和非const转换，即对表达式添加或者去除const属性，但是不能改变表达式的类型。
旧式转换则是从C语言继承而来的。形如int(n)或者(int)n
练习4.1：表达式 5 + 10 * 20 / 2 的求值结果是多少？
105
练习4.2：根据4.12节中的表，在下述表达式的合理位置添加括号，使得添加括号后运算对象的组合顺序与添加括号前一致。
(a) *vec.begin() //*(vec.begin()) (b) *vec.begin() + 1 //(*(vec.begin())) + 1
练习4.3：C++语言没有明确规定大多数二元运算符的求值顺序，给编译器优化留下了余地。这种策略实际上是在代码生成效率和程序潜在缺陷之间进行了权衡，你认为这可以接受吗？请说出你的理由。
不可以接受，过度散漫。
练习4.4：在下面的表达式中添加括号，说明其求值的过程及最终结果。编写程序编译该（不加括号的）表达式并输出结果验证之前的推断。
12 / 3 * 4 + 5 * 15 + 24 % 4 / 2 //91
练习4.5：写出下列表达式的求值结果。
(a) -30 * 3 + 21 / 5 //-86 (b) -30 + 3 * 21 / 5 //-18 (c) 30 / 3 * 21 % 5 //0 (d) -30 / 3 * 21 % 4 //-2
练习4.6：写出一条表达式用于确定一个整数是奇数还是偶数。
-1 % 2 == 0
练习4.7：溢出是何含义？写出三条将导致溢出的表达式
溢出是某个对象的大小超过某种类型的最大值或者最小值，导致无法存储。
char c = 999; short s = 655360; unsigned ui = -1;
练习4.8：说明在逻辑与、逻辑或及相等性运算符中运算对象求值的顺序。
逻辑与先求左侧值，左侧为真，则继续求右侧值。
逻辑或先求左侧值，左侧为假，则继续求右侧值
相等性运算符没有规定求值顺序。
练习4.9：解释在下面的if语句中条件部分的判断过程。
const char *cp = "Hello World"; if (cp && *cp)
首先判断cp是否为空指针，如果不是，再解引用cp，看是否为空字符串，不为空则执行if的语句
练习4.10：为while 循环写一个条件，使其从标准输入中读取整数，遇到 42 时停止。
int i; while (cin >> i && i != 42)
练习4.11：书写一条表达式用于测试4个值a、b、c、d的关系，确保a大于b、b大于c、c大于d。
a > b && b > c && c > d
练习4.12：假设i、j 和k 是三个整数，说明表达式 i != j < k 的含义。
先判断j是否小于k，若小于返回true，否则返回false，然后将返回的bool值提升为0或1,再与i的值进行比较，比较后返回一个布尔值。
练习4.13：在下述语句中，当赋值完成后 i 和 d 的值分别是多少？
int i; double d; (a) d = i = 3.5; // i = 3, d = 3.0 (b) i = d = 3.5; // d = 3.5, i = 3
练习4.14执行下述 if 语句后将发生什么情况？
if (42 = i) // 编译错误，赋值运算符左侧要求是非const左值，字面值是右值。 if (i = 42) // 编译成功，若i是非const的，则恒成立
练习4.15下面的赋值是非法的，为什么？应该如何修改？
double dval; int ival; int *pi; dval = ival = pi = 0;
赋值运算符是右结合的，且返回赋值运算符左侧的对象，因此pi优先运算，赋值完毕后返回一个空指针，再去对int类型的ival进行赋值，由于指针类型无法与整型进行互相转换，因此赋值非法，应该修改为 pi=0;dval=ival=0;
练习4.16：尽管下面的语句合法，但它们实际执行的行为可能和预期并不一样，为什么？应该如何修改？
(a) if (p = getPtr() != 0) (b) if (i = 1024)
若p和i不是const变量，则if语句的条件恒成立，应该修改为
(a) if ((p=getPtr()) != 0) (b) if (i == 1024)
练习4.17：说明前置递增运算符和后置递增运算符的区别。
前置版本对对象作出改变后，返回改变后的对象本身，是一个左值。而后置版本则是改变对象后，返回对象改变前的副本，是一个右值。
练习4.18：如果第132页那个输出vector对象元素的while循环使用前置递增运算符，将得到什么结果？
开头从第二个元素开始解引用，末尾解引用vector最后一个元素之后的尾后迭代器，将会导致溢出。
练习4.19假设 ptr 的类型是指向 int 的指针、vec的类型是vector、ival的类型是int，说明下面的表达式是何含义？如果有表达式不正确，为什么？应该如何修改？
(a) ptr != 0 && *ptr++ (b) ival++ && ival (c) vec[ival++] <= vec[ival]
(a) 先判断ptr是否为空指针，若不为空，先将ptr递增使其指向下一个int元素，然后对递增前的ptr解引用，并判断解引用后的值是否为0
(b) 先将ival的值自增加1，然后判断自增前的值是否为0，不为0则再判断自增后的值是否为0
(c) C++没有规定<=运算符的求值顺序，应修改为vec[ival]<=vec[ival+1]
练习4.20：假设iter的类型是vector<string>::iterator, 说明下面的表达式是否合法。如果合法，表达式的含义是什么？如果不合法，错在何处？
(a) *iter++; //合法，将iter指向下一个元素，解引用移动前的迭代器 (b) (*iter)++; //不合法，字符串没有自增运算 (c) *iter.empty(); //不合法，访问iter的成员empty，但iter是个迭代器，没有empty成员 (d) iter->empty(); //合法，检查元素是否为空字符串
(e) ++*iter; //不合法，字符串没有自增运算
(f) iter++->empty(); //合法，将iter指向下一个元素，检查移动前的元素是否为空字符串
练习4.21：编写一段程序，使用条件运算符从 vector 中找到哪些元素的值是奇数，然后将这些奇数值翻倍。
#include <iostream> #include <vector> using namespace std; int main() { vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9}; for (auto &i : v) { cout << ( (i % 2 == 0) ? i : i * 2 ) << ' '; } return 0; }
练习4.22：本节的示例程序将成绩划分为high pass、pass和fail三种，扩展该程序使其进一步将 60 分到 75 分之间的成绩设定为low pass。要求程序包含两个版本：一个版本只使用条件运算符；另一个版本使用1个或多个if语句。哪个版本的程序更容易理解呢？为什么？
#include <iostream> using namespace std; int main() {
int grade; (grade > 90) ? "high pass" : (grade > 60 && grade < 75) ? "low pass" : (grade > 60) ? "pass" : "fail"; if (grade > 90) cout << "high pass "; if (grade > 75) cout << "pass "; if (grade > 60 ) cout << "low pass "; else cout << "fail "; return 0; }
if语句版本容易理解。条件运算符嵌套层数过多，代码难以阅读，if语句条理清晰，容易理解。
练习4.23：因为运算符的优先级问题，下面这条表达式无法通过编译。根据4.12节中的表（第147页）指出它的问题在哪里？应该如何修改？
string s = "word"; string pl = s + s[s.size() - 1] == 's' ? "" : "s" ;
加运算符优先级比相等运算符优先级高，导致无法编译通过。
应修改为
string pl = s + (s[s.size() - 1] == 's' ? "" : "s") ;
练习4.24：本节的示例程序将成绩划分为 high pass、pass和fail三种，它的依据是条件运算符满足右结合律。假如条件运算符满足的是左结合律，求值的过程将是怎样的？
如果条件运算符满足的是左结合律。
示例程序将会被解读成 finalgrade = ((grade > 90) ? "high pass" : (grade < 60)) ? "fail" : "pass"; 先判断grade > 90是否成立，根据返回值来执行"high pass"或者grade < 60， 然后将"high pass"或grade < 60中的一个作为最后的条件来判断。
练习4.25：如果一台机器上int占32位、char占8位，用的是Latin-1字符集，其中字符'q'的二进制形式是01110001，那么表达式'q' << 6的值是什么？
首先提升为整型，然后对提升后整型左移6为，得到：00000000 00000000 00011100 01000000
练习4.26：在本节关于测验成绩的例子中，如果使用unsigned int作为quiz1的类型会发生什么情况？
因为unsigned int标准规定最小为16位，因此有可能导致无法存储，产生未定义的行为。
练习4.27：下列表达式的结果是什么？
unsigned long ul1 = 3, ul2 = 7; (a) ul1 & ul2 //返回3 (b) ul1 | ul2 //返回7 (c) ul1 && ul2 //返回bool值true (d) ul1 || ul2 //返回bool值true
练习4.28：编写一段程序，输出每一种内置类型所占空间的大小。
#include <iostream> using namespace std; int main() { cout << sizeof(bool) << ' '; cout << sizeof(char) << ' '; cout << sizeof(wchar_t) << ' '; cout << sizeof(char16_t) << ' '; cout << sizeof(char32_t) << ' '; cout << sizeof(short) << ' '; cout << sizeof(int) << ' '; cout << sizeof(long) << ' '; cout << sizeof(long long) << ' '; cout << sizeof(float) << ' '; cout << sizeof(double) << ' '; cout << sizeof(long double) << ' '; return 0; }
练习4.29：推断下面代码的输出结果并说明理由。实际运行这段程序，结果和你想象的一样吗？如不一样，为什么？
int x[10]; int *p = x; cout << sizeof(x)/sizeof(*x) << endl; //输出10，sizeof计算数组名时不转换为指针，40/4=10 cout << sizeof(p)/sizeof(*p) << endl; //输出2,64位系统指针是8字节，int是4字节，8/4=2
练习4.30：根据4.12节中的表（第147页），在下述表达式的适当位置加上括号，使得加上括号之后表达式的含义与原来的含义相同。
(a) sizeof x + y //(sizeof x) + y (b) sizeof p->mem[i] //sizeof ((p->men)[i]) (c) sizeof a < b //(sizeof a) < b (d) sizeof f() //sizeof (f())
练习4.31：本节的程序使用了前置版本的递增运算符和递减运算符，解释为什么要用前置版本而不用后置版本。要想使用后置版本的递增递减运算符需要做哪些改动？使用后置版本重写本节的程序。
本节的程序中使用前置版本或者后置版本的效果是一样的，但是后置版本还需要保留改变前的变量并进行返回，这是额外的无任何意义的操作，因此无需使用后置版本。这里前置版本和后置版本的效果是一样的，无需任何改写。
练习4.32：解释下面这个循环的含义。
constexpr int size = 5; int ia[size] = {1, 2, 3, 4, 5}; for (int *ptr = ia, ix = 0; ix != size && ptr != ia + size; ++ix, ++ptr) { /* ... */ }
这个循环在遍历数组 ia，ix和ptr都是用于循环是否结束的判断依据。
练习4.33：根据4.12节中的表（第147页）说明下面这条表达式的含义。
someValue ? ++x, ++y : --x, --y //someValue为真，则分别递增x和y，然后返回y，否则递减x，然后返回x，再x,--y，先丢弃x,然后递减y，返回y
练习4.34：根据本节给出的变量定义，说明在下面的表达式中将发生什么样的类型转换：
(a) if (fval) (b) dval = fval + ival; (c) dval + ival * cval;
需要注意每种运算符遵循的是左结合律还是右结合律。
(a) bool转换
(b) ival转换为float，计算完的结果转换为double
(c) cval转换为int，计算完毕后转换为double
练习4.35：假设有如下的定义，
char cval; int ival; unsigned int ui; float fval; double dval;
请回答在下面的表达式中发生了隐式类型转换吗？如果有，指出来。
(a) cval = 'a' + 3; (b) fval = ui - ival * 1.0; (c) dval = ui * fval; (d) cval = ival + fval + dval;
(a)'a'转换为int，计算完后int转换为char
(b)ival转换为double，ui转换为double，计算完后double转换为float
(c)ui转换为float，计算完后float转换为double
(d)ival转换为float，计算完后float转换为double，最后计算完后double转换为char
练习4.36：假设i是int类型，d是double类型，书写表达式 i*=d 使其执行整数类型的乘法而非浮点类型的乘法。
i *= int(d); //或者 i*= static_cast<int>(d);
练习4.37：用命名的强制类型转换改写下列旧式的转换语句。
int i; double d; const string *ps; char *pc; void *pv; (a) pv = (void*)ps; // pv = static_cast<void*>(const_cast<string*>(ps)); (b) i = int(*pc); // i = static_cast<int>(*pc) (c) pv = &d; // pv = static_cast<void*>(&d) (d) pc = (char*)pv; // pc = static_cast<char*>(pv)
练习4.38：说明下面这条表达式的含义。
double slope = static_cast<double>(j/i);
将 j/i 的结果转换为 double，然后赋给slope。