4 表达式 | Expression

表达式

REF

An expression is a sequence of operators and their operands, that specifies a computation.

Expression evaluation may produce a result (e.g., evaluation of 2+2 produces the result 4) and may generate side-effects (e.g. evaluation of std::printf("%d",4) prints the character '4' on the standard output).

基本概念

分类

根据运算对象数量可分为一元运算符 unary operator、二元运算符binary operator等，函数调用也是一种特殊的运算符。

类型转换

在不同类型对象进行运算时，常常会发生类型转换。如小整数类型一般会被 提升 promote 成较大整数类型。

重载运算符 overloaded operator

当用户对类类型的对象进行运算时，可以自定运算符及其含义，称为 重载运算符 overloaded operator 。IO库zhongde'>>'和'<<'，以及vector和string对象中的许多运算符都是重载的运算符。

左右值

C++表达式可以分为：

lvalue and rvalue
glvalue and prvalue

其中：
lvalue+xvalue=glvalue；prvalue+xvlaue=rvalue

简单来说，左值用对象的身份，右值用对象的数值。

详见 https://en.cppreference.com/w/cpp/language/value_category

优先级 precedence、结合律 associativity、求值顺序 order of evaluation

优先级和结合律

https://en.cppreference.com/w/cpp/language/operator_precedence

求值顺序

参见：https://en.cppreference.com/w/cpp/language/eval_order

若某个语句没有指定执行顺序，但表达式指向并修改了同一个对象，则无法明确何时、如何对该对象求值，会引发错误产生未定义的行为 undefined behavior。

If a side effect on a scalar object is unsequenced relative to another side effect on the same scalar object, the behavior is undefined.

 i = ++i + 2;       // undefined behavior until C++11
 i = i++ + 2;       // undefined behavior until C++17
 f(i = -2, i = -2); // undefined behavior until C++17
 f(++i, ++i);       // undefined behavior until C++17, unspecified after C++17
 i = ++i + i++;     // undefined behavior

If a side effect on a scalar object is unsequenced relative to a value computation using the value of the same scalar object, the behavior is undefined.
```
cout << i << i++; // undefined behavior until C++17
a[i] = i++;       // undefined behavior until C++17
n = ++i + i;      // undefined behavior
```

算术运算符 arithmetic operators

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

逻辑logical 和比较comparison 运算符

//logical operator
!a
a && b
a || b

//comparison operator
a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b

短路求值 short-circuit evaluation

逻辑运算符都是从左往右求值，直到无法确定后再从右开始。

|| 当且仅当左侧为假才向右计算
&& 当且仅当左侧为真才向右计算
使用以上规则可以规避某些溢出，如：
```
index != s.size() && !isspace(s[index])
```
该式若改变 && 两端顺序，则isspace首先因下标越界而出错。

赋值运算符 assignment operator

赋值运算符左侧对象必须是一个可修改的左值。结果是左侧运算对象，且是一个左值。

a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

右结合律

int a1, a2;
a1 = a2 = 0;  //正确，从右往左

int a3, *a4;
a3 = a4 = 0;  //错误，类型不同且无法转换

复合赋值运算符

假设算术运算符形如 X ，则：

a = a X b; 等价于 a X= b;，而左边求值两次，右边一次。

递增/递减运算符 increment/decrement operator

前置版本++i：首先将运算对象加1，然后将改变后的对象作为结果继续运算。更广泛使用，能避免不必要的语句，如for循环中会少进行一次判断。
后置版本i++: 将运算对象加1，但求值结果是运算对象改变之前的值的副本。较少使用，需要先储存副本，增加了不必要的运算。

后置自增和解引用混用

*p++ 是一种常用的避免无法输出首字母的表达式。由于递增递减的优先级高于解引用，该式等价于*(p++)。

auto* p = v.begin();
while (p != v.end()) 
    cout<< *p++ <

 
 用前置自增改写会增加代码而变得不简洁： 
 auto* p = v.begin();
while (p != v.end()) {
    cout<< *p <
 
 使用递增递减应避免未定义行为 
 成员访问运算符 member access operator 
 a[b]
*a
&a
a->b
a.b
a->*b
a.*b
 
 https://en.cppreference.com/w/cpp/language/operator_precedence 
 a->b等价于(*a).b而不是*a.b。后者相当于a本身是一个指针，试图访问该指针的b成员，自然出错。 
 条件运算符 
 cond ? expr1 : expr2 ：先求cond的值，若真则对expr1求值并返回，否则对expr2求值并返回。 
 条件运算符嵌套 
 const int A = 90;
const int B = 80;
const int C = 70; 
const int D = 60;

int main(){
    int grade = 0;
    cin>>grade;
    string str_grade = (grade>=A)? "A" : 
                       (grade>=B)? "B" :
                       (grade>=C)? "C" :
                       (grade>=D)? "D" : "F";
    cout<
 
 相较于switch和if等语句，由于会逐渐向后计算，使用该方式可减少判断条件的长度；但由于前式都需要计算，可能会略微减慢。 
 位运算符 
 用于整数类型的运算对象并将其视为二进制位的集合，并提供检查和设置二进制位的功能。位运算符同样可用于bitset的标准库类型。 
 如果运算对象类型是小整型，会被自动提升promote成较大整型。此外，由于不同编译器位运算对最前面符号位的处理方式不同，可能出现未定义undefined结果，因此避免为有符号数进行位运算。 
 ~a
a & b
a | b
a ^ b
a << b
a >> b
 
  
   若是短类型，先进行提升：短类型前补满0转为长类型； 
    
    无论是否带符号，提升后默认是有符号值。 
   
  
   若超限，则： 
    
     超上限：减去容量(char: 256=0400)； 
     超下限：加上容量。 
   
  
  无符号数按位取反：容量减去当前值； 
   有符号数按位取反（提升并使容量合法时）： 
    
    所有位按位取反； 
    若取反后符号位是1，显示的值是再（对绝对值）按位取反并+1。相当于 ~正->负：绝对值 +1 变符号； 
    若取反后符号位是0，显示的值是再（对绝对值）按位取反并-1。相当于 ~负->正：绝对值 -1 变符号。 
   
  
  
 //char: int8_t;
//sizeof(unsigned char): 1byte=8bits; 3bit/num;
//char-max = 0B11'111'111 = 0377 = 255 = 0xFF = unsigned char -1;
unsigned char c1o = 0227;
//unsigned char 0b10'010;111 = 151
//to unsigned int 0b00000000'00000000'00000000'10010111
unsigned int i1o = 0227;
//unsigned int 0b00000000'00000000'00000000'10010111
auto c1o_(~c1o);
//int 0b11111111'11111111'11111111'01101000  =>
//int -(0b00000000'00000000'00000000'10010111+1) => int -152
auto i1o_(~i1o);
//unsigned int 0b11111111'11111111'11111111'01101000 
//to unsigned int 4294967144
cout<
 
 不超限的短类型负数： 
 signed char c1o = -027; 
//注意char可能为unsigned也可能为signed

int x = -0b00000000'00000000'00000000'00010111;
int xx = 0b11111111'11111111'11111111'11101001;

cout<<~c1o<<'\t'<<~xx<<'\t'<<~x<
 
 负号和按位取反的区别： 
 int main(){
    int a = ~0b00000000'00000000'00000000'00000100;
    //int a = ~5;
    int b = 0b11111111'11111111'11111111'11111011;
    //int b = -5;
    int c = -0b00000000'00000000'00000000'00000101;
    //int c = -5;
    cout<
 
 负号返回值增加了一个取补码的过程，在表达式中的结果同样也是提符号-取补码作为绝对值-进行输出。而按位操作单纯对位操作，不取补码。二者单独使用均可逆，但混用时注意流向。 
 移位运算符（io运算符）满足左结合律。 
 sizeof运算符 
 返回的是某表达式或类型名所占的字节数。该运算符满足右结合律，所得的值是一个size_t类型的常量表达式。sizeof并不实际计算表达式的值而是直接返回字节数。运算符的运算对象形式如下： 
 sizeof (type);
sizeof expr;
 
 sizeof *p比较特殊。首先，由于sizeof()满足右结合律并且优先级等于*运算符，按照从右向左的顺序组合，等价于sizeof(*p)。此外，由于不会实际求运算对象的值，即使是无效指针也可以安全获取结果。 
 一些规则： 
  
   sizeof(char): 1 
  对string或vector执行sizeof只返回该类型固定部分的大小而不是对象中元素占了多少空间。 
  若ia是个数组，可以使用 sizeof(ia)/sizeof(ia[0]) 或者 sizeof(ia)/sizeof(*ia) 得到数组大小。 
    
    注意不要使用指向数组的指针：sizeof(p)/sizeof(*p)  
   
  
   sizeof的返回值是一个常量表达式，因此可以用该结果声明数组维度。 
  
 逗号运算符 comma operator 
  
  用在for循环中，实现多个变量的自增/自减 
  用在同一基本类型的连续赋值中 
  
 类型转换 
 如果两种类型有关联，则当程序需要其中一种类型的运算对象时，可以用另一种关联类型的对象或值来替代：若两种类型可以相互转换conversion，则二者就是关联的。 
 隐式转换 implicit conversion：自动执行，无需人为介入。如下列情况： 
  
  比int小的整型提升时； 
  非布尔转为布尔； 
  初始化的初始值转为变量的类型；赋值中右侧类型转为左侧类型 
  多种类型进行混合算术运算； 
  函数调用时的类型转换。 
  
 算数转换 arithmetic conversion 
 把一种算术类型转换成另一种算术类型。运算符的运算对象将转换成最宽的类型。例如有整型和浮点就都换为浮点；含有long double，则都换为long double。 
 整型提升integral promotion 
  
  对于 bool, char, signed char, unsigned char, short, unsigned short，只要它们所有可能的值都能存在int里，它们就会提升成int类型，否则提升成unsigned int类型。 
  对于 wchar_t, char16_t, char32_t，提升为能够容纳它们的 int, unsigned int, long, unsigned long, long long, unsigned long long 中最小的一种类型。 
  
 无符号类型 
 在进行整型提升后，再决定是否是带符号的类型。
 具体规则如下： 
  
  若只同时存在有符号或同时存在无符号，则转为容量较大的类型（无论正负）。 
   若无符号类型 >= 有符号类型，均转为无符号类型： signed char a = -10;
unsigned int b = 1;
unsigned long c = 3.0;
auto d = a+b+c; //unsigned long
  
   若有符号类型 > 无符号类型： 
    
    若无符号类型的所有值都可以存在有符号类型中，则转为带符号类型 
    若不能，则转为无符号类型 
    主要依赖于系统或编译器对类型大小的定义。 
   
  
  
 其他隐式类型转换 
 https://en.cppreference.com/w/cpp/language/implicit_conversion 
 特殊类型 
 某些特殊类型如size_t, size_type, ptrdiff_t, wchar_t都可以隐式转换为相应的合理类型（主要由操作系统和编译器决定）。为了程序的可移植性，应多使用这些类型。 
 数组转为指针 
 int ia[10];
int* ip = ia; //右边隐式转换为指向首元素的指针
int* ip = std::begin(ia);
 
 上述转换不会在decltype, &, sizeof, typeid中发生。用引用初始化数组也不会发生。 
 指针的转换 
  
  常量整数值的指针或者nullptr能转为任意指针类型； 
  指向任意非常量的指针能转换为void*； 
  指向任意对象的指针能转换成const void*。 
  再有继承关系的类中还有其他转换方式。 
  
 指向常量的指针 
 允许将指向非常量类型的指针转换成指向相应常量类型的指针（增加底层const），反之由于试图删除底层const，无法实现。 
 int a = 1;
const int& ra = a;
const int* pa = &a;
int& rr = ra; //错误
int* pp = pa; //错误
int* const ppc = pa; //错误，没有底层，顶层自然不一致
 
 类类型定义的转换 
 显式转换 
 强制类型转换 cast 
 具体参见：
 https://en.cppreference.com/w/cpp/language/explicit_cast 
 命名的强制类型转换 
 形式如：
 cast-name(expression) 
  
  type：目标类型。若是引用类型，则结果是左值。 
  expression：要转换的表达式 
  cast_name：包括 static_cast, dynamic_cast, const_cast, reinterpret_cast 指定了转换方式。 
  
 注意：不可用于左值，使用cast后的值进行初始化等操作时可与auto配合使用以减少类型名的重复编写。 
 static_cast 
 任何具有明确定义的类型转换，只要不包含底层const就可以使用。 
 static_cast不能转换掉expression的const、volatile、或者__unaligned属性。 
 int a = 1;

float b = static_cast(a);
//两种旧式转换方式
float c = float(a);
float d = (float)a;

int* const  pc = &a;
int* p = static_cast(pc); 
int* pp = pc;           //而且非底层const不必static_cast可以直接转换
 
 const_cast 
 只能改变运算对象的底层const，这种行为称为 去掉const性质 | cast away the const。注意必须具有底层const。若对象是个常量（具有顶层const）则 
 int a = 1;

const int* pa = &a;
int* p = const_cast(pa);

const int& ra = a;
int& r = const_cast(ra);
 
 reinterpret_cast 
 reinterpret_cast通常为运算对象的位模式提供较低层次上的重新解释，即以二进制存在形式的重新解释
 可将int*转为char*等。使用此强制转换较为危险。 
 int* const pp = &b;
unsigned int* qq = reinterpret_cast(pp); 
unsigned int* qq = reinterpret_cast(pp); 
 
 https://en.cppreference.com/w/cpp/language/reinterpret_cast 
 dynamic_cast 
 https://en.cppreference.com/w/cpp/language/dynamic_cast 
 pointer_cast 
 https://en.cppreference.com/w/cpp/memory/shared_ptr/pointer_cast 
 std::static_pointer_cast, std::dynamic_pointer_cast, std::const_pointer_cast, std::reinterpret_pointer_cast
 
 旧型强制转换 
 type(expr)   //函数形式
(type)expr   //C语言风格
 
 根据涉及类型不同，可以具有与 const_cast, static_cast, reinterpret_cast 任意一种相似的行为。若替换为const_cast和static_cast合法，则行为与命名一致，否则执行的是reinterpret_cast。 
 运算符优先级

4 表达式 | Expression

表达式

基本概念

分类

类型转换

重载运算符 overloaded operator

左右值

优先级 precedence、结合律 associativity、求值顺序 order of evaluation

优先级和结合律

求值顺序

算术运算符 arithmetic operators

逻辑logical 和 比较comparison 运算符

短路求值 short-circuit evaluation

赋值运算符 assignment operator

右结合律

复合赋值运算符

递增/递减运算符 increment/decrement operator

后置自增和解引用混用

使用递增递减应避免未定义行为

成员访问运算符 member access operator

条件运算符

条件运算符嵌套

位运算符

移位运算符（io运算符）满足左结合律。

sizeof运算符

逗号运算符 comma operator

类型转换

算数转换 arithmetic conversion

整型提升integral promotion

无符号类型

其他隐式类型转换

特殊类型

数组转为指针

指针的转换

指向常量的指针

类类型定义的转换

显式转换

命名的强制类型转换

static_cast

const_cast

reinterpret_cast

dynamic_cast

pointer_cast

旧型强制转换

运算符优先级

你可能感兴趣的:(4 表达式 | Expression)

逻辑logical 和比较comparison 运算符