What & How & Why

C++ Primer 笔记 第四章
我的笔记均包含大量个人理解内容，存在一定偏差。如果您发现错误，请留言提出，谢谢！

运算符分为一元运算符（unary operator )和二元运算符 （Binary operator）。“元”代表有几个operands。每个运算符的运算优先级（precedence） 和结合律（associativity）由运算符自身决定。 我们在对包含多个运算符的表达式进行计算的时候，常常会遇到一些需要考虑的问题：比如运算优先级，operands的转化，运算符的重载等等。要讨论这些规则之前，我们必须先明白两个概念：左值（Lvalues）和右值（Rvalues)

每个表达式都有至少一个左值或者右值来充当自己的operand。 那什么叫左值？我们可以顾名思义，左值当然是能放到左边的了值了。放到什么左边？放到“=”的左边。不过左值不能这么来定义，因为这么定义会有一些例外。比如 const 对象，这是一个左值，但是不能放到“=”左边。书中讲了一个简单的判定规则：当使用左值的时候，我们是使用的对象在内存里的位置；当使用右值的时候，我们使用的是对象的值。看看“=”左边的值，是不是都能取地址，都能赋值？
判断左值的具体方法可以参考：
关于C++左值和右值区别有没有什么简单明了的规则可以一眼辨别？ 看轮子哥的解答。

了解了定义以后，有几个表达式的规则就根据左右值的区分来制订了：

1. 在表达式中，左值可以取代右值，反过来不行。
2. 赋值运算中，“=”号左边如果是一个Nonconst的左值，那么表达式得到的结果类型也是左值。（很好想象，比如 a = 10; 得到的是a）
3. 取地址操作需要一个左值，而操作结果返回一个指针，是右值。（当然了，左值代表位置，取地址当然是对左值操作。取回的是地址的具体数值，当然是右值。）
4. 解引用（*）运算，下标运算和迭代器的解引用，都产生左值。
5. 迭代器的自增 / 自减 也需要左值进行运算，但只有prefix版本返回左值（++ / –i）。
6. 用decltype对表达式进行操作，如果表达式返回左值，那么decltype的返回值是一个引用。

关于运算符对operand的转化后面会详细说到详细的规则。
对于运算符的重载，要注意的是运算符不管怎么重载，operand的类型都是由重载的定义来决定的。但是，重载并不能改变运算符本身的运算优先级和结合律。

优先级和结合律并不能保证运算对象的求值顺序，operand的运算顺序在大多数情况下是未知的；而有时候这种未知的操作顺序会带来很严重的后果，比如：

int i = 0;
cout << i << ++i << endl;

在这里我们根本就不知道i是多少。如果前面的i先运算，那么我们打印的是0, 1;但如果后面的++i先运算，我们打印的就是1,1了，这显然是不合理的。
对于没有指定operand运算顺序的表达式，如果operands的运算牵涉并改变了同一个值，结果将导致undefined.
那么问题来了，既然这么危险，为啥C++不直接禁止这么用？
我们再来看一个例子：

f() + g() * h() + j();

我们知道这几个function我们不知道谁先进行运算，因此如果他们改变同一个对象，我们又要得到undefined的值了。但是如果他们操作的是不同的对象呢？
试想一下，如果C++强行规定了运算顺序，那么不管怎么样，我们同时只能进行两个functions的运算。但如果我们不指定顺序，那么这4个functions是可以同时进行运算的。这样的话，不指定顺序比制定顺序快了一倍。当我们明白这些function在操作什么时，我们也不需要害怕上述的危险了，反而能得到性能的提升。这也很符合C++的哲学：让程序员来决定程序的好坏。

当然如果把握不准，我们还有几个方法来处理这个问题：

1. 用括号保证优先级。
2. 如果改变了operand的值，就不要把这个operand再放到同一个表达式的其他任何地方。（有例外，如实际上已经指定了优先级的*iter++，详见section4.1）

对于一些运算符，operand运算的顺序是指定了的。比如逻辑运算符(&& / || )，条件运算符(? :)，逗号运算符（，）。

算术运算符的优先级可以同样可以参考P166。有几点需要注意的是：

1. 一元运算符的优先级 > 乘除 > 加减。
2. 运算的时候都是从左到右（左结合律）
3. 算术运算符得到的结果都是右值。
4. 一元“+”运算符可以应用到指针和算术类型上，返回的值是operand的拷贝。
5. 整数之间的除法结果是整数。

算术运算的异常通常有几种情况：

• 如果我们进行了了一些数学意义上无意义的运算，那么很可能导致算术运算的异常。比如：除0操作
• 超出了类型范围算术运算(overflow)，比如：

short si = 32767;
     si += 1; //error, overflows.

注意：这样的错误编译器很可能不会给出异常，因为在有些系统里是有值得出的，比如上述计算得出si的值为-32768（我的系统）。

对于整数的除法，现行的新标准已经禁止商像负无穷方向取整了。
对于余数的计算 M%N，有：

1. M % (-N) = M % N
2. -(M) % N = - (M % N)

逻辑运算符都是先求左边operand的值，根据左边结果来判定是不是要求右边的值，这种求值方式我们称为short-circuit evaluation. && / || / !都是比较常见的运算符，主要用于条件判断。对于默认的条件判断来说，括号里的值只要非负，就为真。比如：

while(a); // true if a is any non-zero value.

这里牵涉到类型的隐式转换，后面会cover相关内容。

关系运算符用于鉴别operand的大小，所以也是返回bool类型的值。
因为关系运算是有结合律的，所以不能进行连续的关系运算，会导致结果错误。一般都与逻辑运算符混用，达到不同的条件判断。
注意：不进行关系运算的时候，不要用true / false来进行运算。（进行比较后会有隐式转换）

赋值运算符有几个要点：

1. 赋值运算符的左边必须是可以操作的左值。
2. 赋值结果的类型与左边的operand相同。
3. 赋值运算中如果左右两个operand的类型不同，右operand会转化成和左operand相同的类型。
4. C++11中，List初始化不能进行narrow conversion(老版本是可以的，反过来也是可以的，比如用double去装int）,list可以为空（进行默认初始化）。

赋值运算的结合律是从右到左的。比如：

int ival, jval;
ival = jval = 0; // expression will do jval = 0 first; then do ival = jval

注意：在多重赋值中，所有的对象类型必须一致，或者可以通过类型转换达到一致。

假设用自增运算符（自减也是相同的）对变量 i 进行操作，那么我们会得到两种情况：++i 和 i++.
简单的说来：

• ++i 是先自增再运算
• i++ 是先运算再自增

从结果来说：

• ++i 返回的是 i+1的值，返回的值是左值。
• i++ 返回的是 i 的值，返回的是一个右值。

从程序效率上来说：

• ++i 做了两步：取值，增加。
• i++ 做了三步：取值，增加，再取原来的值。

对于一些迭代器运算，++i的效率要高于i++的。详情可以参考：
在程序开发中，++i 与 i++的区别在哪里？ 叶王的回答。

有时候我们会希望使用变量的值，然后再对其加1，这时候我们可以用*iter++这样的表达式。比如我们要遍历打印一个vector：
如果我们用一般的方法，我们需要做两部：

auto pbeg = v.begin();
while (pbeg != v.end()) {
    cout << *pbeg << endl; // print current value;
    ++pbeg; // iterator move to the next position;
}

但现在有了 *iter++这种形式，语句就可以更简洁了：

auto pbeg = v.begin();
while (pbeg != v.end())
    *pbeg++; // print current value then move to the next position.

而对于 *pbeg++ 来说，解引用运算的优先级高于自增。所以这个表达式也等价于*(pbeg++)。
注意：除非operand的运算顺序明显（如上例），避免用自增 / 自减 运算对同一个数值进行运算，修改（原因见section1.3)

成员运算符有 “.” 和 “→“两种。 ”.”(dot)运算符比较常用，一般用于访问成员，比如访问对象a的function(),我们就可以写成：a.function()。
有时候我们知道对象a的指针p，用p来访问function()就要先解引用，再访问，比如：(*p).function()。注意：因为解引用的优先级低于dot成员访问，所以必须用括号强制先行解引用运算。
这种方法比较繁琐，我们可以用“→“运算符来代替，比如如下两种方法都是等价的：

(*p).function();
p->function();

对于dot运算，运算结果与参与运算对象的类型相同（这里指左值/右值）。在(*p).function()里，*p是左值，所以我们可以得知”→“运算符返回的是左值。

if-else语句可以用条件运算符的形式表达出来：

condition ? expr1(if_true) : expr2(if_false);

如果两个条件表达式都是左值，那么运算的结果是左值，否则结果是右值。
有几点需要注意的是：

• 用条件运算符进行嵌套会大大影响程序的可读性。
• 条件运算符的优先级非常低，如果在复杂的表达式中运用，必须要用括号保证优先级，比如：

cout << (condition ? expr1(if_true) : expr2(if_false)) << endl;

位运算符作用于整数运算，并且把运算对象都当作是二进制运算。位运算有几种比较重要的运算符：

~expr; // bitwase NOT, 按位求反
expr1 << expr2; //left shift, 左位移 
expr1 >> expr2; //right shift, 右位移 
expr1 & expr2 ;//bitwise AND, 按位与运算，只有位都为1的之后为真
expr1 ^ expr2; //bitwise XOR, 按位异或运算，位异号的时候为真
expr1 | expr2; //bitwise OR, 按位或运算，只要位中有一个为1，就为真

对于位移运算符”», «” ，我们需要注意的是：

1. 位移运算符右边的operand必须非负，而且值必须小于结果的位数，否则会导致undefined。
2. 对于位运算符，我们最好采用unsigned类型来进行计算。如果位运算符的operand带有符号，那么运算符对operand符号位的处理是根据机器来指定的。换句话说，符号位的处理是没有明确定义的；如果运算导致符号位被修改（比如位移操作），那么这个运算就会导致undefined.
3. 位移运算的结合律是从左到右的。
4. 位移运算的优先级高于关系运算符，复合使用的时候必须要用括号确定优先级。

位运算因为只进行二进制的条件和位移运算，所以效率是非常高的。我们通常可以把位运算引用到一些比较简单的条件判断上，比如判断奇偶：

int a;
a % 2; //the way we used to evaluate odd / even
a & 0x1; // using AND. if the last bit of a is 0, the expression will return 0; then we know a is a even. If the expression returns 1, then a is a add。

还有其他更多高效率的简单位运算应用，详情可以参考Matrix 67的位运算系列：位运算简介及实用技巧

sizeof会按字节返回一个类型所占的空间。sizeof 满足右结合律，返回的值是一个“size_t”的类型。
有几点要注意的是：

1. sizeof并不会对类型/表达式进行运算，所以即使表达式是无效的（比如无效的指针），sizeof也会计算出值。
2. sieeof对引用的求值返回的是引用绑定的对象所占空间的大小。
3. sizeof对指针的求值返回的是指针所占空间的大小。
4. sizeof对数组的求值返回的是element_space * element_number;因为sizeof不会执行表达式，所以sizeof不会将数组转化成指针处理。
5. sizeof对vector / string 求值只返回fixed size，比如：

   string s1 ="a";
   string s2 ="abcdef";
   vector<int>vi(10,1);
   vector<char>vc(20,'c');
   cout << sizeof(s1) << " " << sizeof(s2) << " " << sizeof(vi) << " " << sizeof(vc) << endl;

   返回的值是：32 32 24 24。
6. 以前用sizeof访问类成员，必须要通过类对象来访问；但是新标准我们可以使用scope运算符来访问，比如：

   sizeof object.member; // the old way
   sizeof class::member; // the new standard

逗号运算符会先对左边的表达式求值，然后丢掉结果；接着会对右边的表达式求值。整个逗号运算的结果是右边表达式的值。

在运算中，两种可以互相转换的类型称之为有关联的。

隐式转换的进行是由计算机根据表达式中operand的类型来判断的。可能发生隐式转换的情况有：

1. 小整型类型（short / char）的提升（转化成较大的整数类型）。
2. 条件语句中，非bool表达式转化成bool表达式。
3. 初始化中，初始值转化为变量的类型；赋值中，右边的operand的类型会自动转化为左边operand的类型。
4. 算术 / 关系运算中，operands需要转化为相同类型。
5. 函数调用的类型转换。

算术类型的转换分为好几种：

• 算术转换：在运算中，operand将被转换为最宽的类型(比如int + double, int会转化成double)。
• 整型的提升。
• 无符号类型的转化；规则分为好几个步骤