粗略的把左值和右值理解成：左值是对象本身，右值是对象的值。操作左值就是用了对象本身，修改左值就是修改了对象本身的内容，返回左值就是把操作后的对象返回。操作右值是操作对象值的拷贝，不会修改对象本身，返回右值就是把值返回，而不返回对象本身。因此：

• 赋值运算是要修改对象本身的，所以它接受的是左值，操作完毕之后返回的也是左值。
• 取址符只需要拿到对象本身的地址的值就好，所以接受的是左值，但是返回的是右值。
• 前置递增递减运算符是要作用于对象本身且返回操作后的值，所以接受和传出的都是左值。
• 后置递增递减运算符也是要作用于对象本身，所以接受左值，但是返回的是旧值，所以传出的是右值。
• 解引用、下标运算符接受和传出的都是左值。
• 算数运算符 + - * / % 的运算对象和求值结果都是右值。

大部分运算符不规定运算对象按什么顺序求值，例如 s = f1() * f2()，我只知道 s 拿到的是两个值的乘积，但是不知道先求 f1() 还是先求 f2()。所以， 当 f1() 和 f2() 会互相影响的时候，该语句的结果就是未定义的。还有一个经典的例子：

int i = 0;
int x = i + (++i) + (i++);
cout << x << ' ' << i << endl;

猜一下 x 结果是多少？如果先计算 i++ 的话，那么返回 0，但是此时 i = 1。然后再计算 i++，返回 2，最后该表达式的值是 2 + 2 + 0 = 4，i 的值是 2。但是如果是另一个顺序，表达式的值就是 0 + 1 + 1 = 2。不同的编译器会有不同的结果，所以这么写是自己给自己挖坑啊！

&&、||、?: 和 , 这四个运算符明确了运算对象的求值顺序。&& 规定先计算左侧运算对象的值，只有当左侧运算对象的值为真的时候才继续计算右侧运算对象的值，否则返回 false。|| 规定先计算左侧运算对象的值，只有当左侧运算对象的值为假的时候才继续计算右侧运算对象的值，否则返回 true。&& 和 || 这种一旦能确定表达式的值就不再往后运算的策略称为短路求值。?: 规定先计算左侧运算对象的值，当左侧运算对象的值为真的时候计算中间运算对象的值并返回，当左侧运算对象的值为假的时候计算右侧运算对象的值并返回。, 规定从左到右计算运算对象的值，只保留并返回最右侧运算结果。

C++11 标准规定整数求商一律向 0 取整。也就是说正数向下取整，负数向上取整。

在不溢出的情况下，-(m/n) = (-m)/n = m/(-n)，(-m)%n = -(m%n)，m%(-n) = m%n。

赋值运算符 = 在赋值成功后会返回赋之后的值，赋值失败后返回 false。

在不需要旧值的时候使用后置递增、递减运算符是一种资源的浪费，还会影响性能。所以建议养成使用前置递增、递减运算符的好习惯，除非必须要使用到旧值。

 cout << ((grade<60) ? "fail" : "pass"); // 正确：输出 pass 或者 fail
 cout <<  (grade<60) ? "fail" : "pass";  // 警告：输出 1 或者 0
 cout <<    grade<60 ? "fail" : "pass";  // 错误：不能比较 cout 对象和 60 

条件运算符的优先级很低，所以在输出表达式中要记得在外层套一个括号。否则会发生意想不到的事情：第二行的执行顺序是

cout << (grade<60);      // 输出 1 或者 0
cout ? "fail" : "pass";  // 当成功输出的时候 cout 为 true，然后返回 "fail" 
                         // 但是由于无人接收所以被丢弃了

第三行的执行顺序是

cout << grade; // 输出 grade 的值
(cout < 60) ? "fail" : "pass";  // 然后比较 cout 与 60，不能比！

~操作符代表按位求反。

强烈建议仅将位运算符用于处理无符号类型，因为有符号类型的首位是符号为，这个符合位如何处理在不同的平台上有不同的表现。

强制类型转换有 static_cast、dynamic_cast、const_cast 和 reinterpret_cast 四种。
static_cast 适用于所有不包含底层 const 的类型转换，而且在使用的时候有很强烈的程序员告知编译器”这么做是我所愿意的“的意味。所以在精度损失的时候编译器不会提醒，因为编译器认为程序员有足够的把握了。一个重要的用途是把 void * 指针转型为任意类型的合法指针，前提是我们清楚所指的对象的类型。例如：

double dval = 3.14;
void *p = &dval;
double *dp = static_cast<double *> (p); // 👌

dynamic_cast 占坑

const_cast 用来改变运算对象的底层 const 特性。例如，可以通过它来强行消除一个对象的底层 const 性质，但是注意返回了右值：

const int ca = 3;
const int *pca = &ca;
int *a = const_cast<int *> (pca);
*a = 2;
cout << ca << ' ' << *a << endl; // 3 2

上面的 ca 并不会被改变，因为 const_cast 返回右值，a 指向了新的一块内存。
const_cast 最有用的地方是函数重载。看下面个函数：

const string &shorterString(const string &s1, const string &s2)
{
    return s1.size() < s2.size() ? s1 : s2;
}

该函数既可以接受常量实参，又可以接受非常量实参。对函数形参使用 const 引用能够避免函数对实参进行拷贝，节省不必要的时间占用。但是你会发现，这样子写的话，函数一定会返回一个 string 的常量引用，不管传入函数的实参是否为常量。如果我们想要让函数返回的类型与实参类型相符，那么我们可以在返回的时候强行剥夺 const 属性：

string &shorterString(string &s1, string &s2)
{
    auto &r = shorterString(const_cast<const string&> (s1),
                            const_cast<const string&> (s2));
    return const_cast<string &> (r);
}

首先将实参强制转换成对 const 的引用，然后对返回的引用强行剥夺它的底层 const 属性 (记住常量引用是底层 const)。

reinterpret_cast 为运算对象的位模式提供较低层次上的重新解释。例如：

int *ip;
char *cp = reinterpret_cast<char *> (ip);

上面的 ip 是一个整形指针，cp 是一个字符指针，但是 cp 指向的却是一个整形。所以后面解引用 cp 的时候，拿到的是 int 而不是 char。reinterpret_cast 并不建议一般人使用，只有精通编译器的人才能正确使用。

除非必要，否则不建议使用强制类型转换。

整形提升用于把小整数类型转换成较大的整数类型：bool char signed char unsigned char short unsigned short 在能存的下的前提下将提升至 int，如果放不下那就提升至 unsigned int。较大的 char 类型 (wchar_t char16_t char32_t)提升至 int unsigned int long unsigned long long long unsigned long long 中能够容纳的最小的类型。

当表达式中既有浮点类型也有整数类型时，整数值将转换成相应的浮点类型。

当某一个运算对象的类型是无符号类型，那么转换的结果依赖于机器中各个整数类型的相对大小。

• 首先执行整数提升，如果提升后的类型匹配，那么就到此为止，如果类型不匹配但符号相同 (要么都带要么都不带)，则小类型转换成大类型。
• 如果一个运算对象是无符号类型，另一个是带符号类型，而且无符号类型大于等于带符号类型，例如 u40 - 13，那么带符号类型将转为无符号类型，这个时候如果带符号类型是负数，那么后果自负。如果带符号类型大于无符号类型，如 u40 - 42，那么此时转换结果依赖于机器。如果无符号类型的值能够存进该带符号类型中，那么无符号类型转为带符号类型；如果放不下的话，那么带符号类型转为无符号类型。