《C++primer学习笔记》——第4章表达式

布满荆棘的人生 2022-10-25 14:15 241阅读 0赞

**此章知识点不多，都是较为基础的或是C语言中学过的，便不多赘述**

# 一、基础\[P120\] #

## 1. 概念 ##

C++定义了一元运算符（如\*,&)、二元运算符(如==),除此之外还有一个三元运算符。函数调用也是一种特殊的运算符，它对运算对象的数量没有限制。

### 运算符重载 ###

当运算符作用于类类型的运算对象时，用户可以自行定义其含义。称之为**运算符重载**。如IO库的<<和>>运算符以及vector、String对象和迭代器使用的运算符都是重载的运算符。  
我们使用重载运算符时，其包括运算对象的类型和返回值的类型，都是由该运算符定义的。但是运算对象的个数、运算符的优先级、结合律都是无法改变的。

### 左值和右值 ###

C++的表达式要不然是**右值**，要不然是**左值**。这两个名词是从C语言继承过来的，原本是为了帮助记忆：左值可以位于赋值语句的左侧，右值不能。常见的左值有以下几个：  
①赋值运算符需要一个（非常量）左值作为其运算对象，得到的结果仍然是一个左值。  
②取地址符作用于一个左值运算对象，返回一个指向该运算对象的指针，这个指针是一个右值。  
③内置解运算符、下标运算符、迭代器解引用运算符、vector和string的下标运算符的求值结果都是左值。  
④内置类型和迭代器的递增递减运算符作用于左值对象，所得的结果仍然是左值

# 二、算术运算符\[P124\] #

**一元运算符的优先级最高(正号、负号)，接下来是乘法和除法，优先级最低的是加法和减法。**

# 三、逻辑和关系运算符\[P126\] #

# 四、赋值运算符\[P129\] #

赋值运算符满足右结合律，这一点与其他的二元运算符不太一样：

int val,jval;
    val = jval = 0;

复合赋值运算，共有10种，分别是：  
\+=      -=    \*=    /=  %=  
<<=   >>=  &=  ^=    |=  
任意一种复合运算符都完全等价于  
a = a *op* b;

# 五、递增递减运算符\[P131\] #

**简洁可以成为一种美德**  
 T I P 1 \\color\{\#FF0000\}\{TIP1\} TIP1：**除非必须，否则不用递增递减运算符的后置版本**  
前置版本的递增运算避免了不必要的工作，它把值加1后直接返回改变了的运算对象。与之相比，后置版本需要将原始值存储下来以便于返回这个未修改的内容。如果我们不需要修改前的值，那么后置版本的操作就是一种浪费。  
 e x a m p l e 1 \\color\{\#0000FF\}\{example1\} example1:输出元素直至遇到第一个负值为止

auto pbeg = v.begin();
    while(pbeg != v.end()&&*pbeg>=0)
    { 
    cout<< *pbeg++<<endl;
    }

但注意不可以使用类似如下的语句：

*beg = toupper(*beg++);//错误：该赋值语句未定义

问题在于赋值运算符左右两端的运算对象都用到了beg，并且右侧的运算对象还改变了beg的值，所以该赋值语句是未定义的，语句有歧义。

# 六、成员访问运算符\[P133\] #

点运算符获取类对象的一个成员；箭头运算符与点运算符有关，表达式*ptr->mem*等价于(\*ptr).mem  
 e x a m p l e 2 \\color\{\#0000FF\}\{example2\} example2

string s1 = "a string", *p = &s1;
    auto n = s1.size();//运行string对象s1的size成员
    n = (*p).size();
    n = p->size();

因 为 解 引 用 运 算 符 的 优 先 级 低 于 点 运 算 符 ， 所 以 执 行 解 引 用 运 算 的 子 表 达 式 两 端 必 须 加 上 括 号 \\color\{\#FF7D00\}\{因为解引用运算符的优先级低于点运算符，所以执行解引用运算的子表达式两端必须加上括号\} 因为解引用运算符的优先级低于点运算符，所以执行解引用运算的子表达式两端必须加上括号

# 七、条件运算符\[P134\] #

条件运算符（**?:**）允许我们把简单的if-else逻辑嵌入到单个表达式当中，条件运算符按照如下形式使用：  
*cond？expr1：expr2*  
当cond为真，则对expr1求值并返回该值，反之则对expr2求值并返回expr2的值，如：

string finalgrade = (grade<60) ? "fail": "pass"

## 嵌套条件运算符 ##

允许在条件运算符内部嵌套另一个条件运算符。也就是说，条件表达式可以作为另一个条件运算符的*cond*或*expr*。如：

finalgrade = (grade>90)?"high pass"
    						:(grade<60) ? "fail":"pass";

## 在输出表达式中使用条件运算符 ##

**条件运算符的优先级非常低**，因此当一条长表达式中嵌套了条件运算子表达式时，通常需要在它两端加上括号。例如，有时需要根据条件值输出两个对象中的一个，如果写这条语句时没把括号写全就可能产生意想不到的结果：

cout<<((grade<60) ? "fail": "pass");//正常输出pass or failed
    cout<<(grade<60) ? "fail": "pass";//输出1或者0
    cout<< grade<60 ? "fail": "pass";//错误，试图比较cout<<grade和60

第三条表达式等价于下面的语句，所以他是错误的：

cout<<grade；//小于运算符的优先级低于位移运算符，所以先输出grade
    cout< 60 ? "fail" : "pass";//然后比较cout和60!

# 八、位运算符\[P135\] #

一种名为bitset(第17章将进行介绍)的标准库类型也可以表示任意大小的二进制位集合，所以位运算同样能用于bitset类型。位运算符主要包括以下6个：

关 于 符 号 位 如 何 处 理 并 没 有 明 确 的 规 定 ， 所 以 强 烈 建 议 仅 将 位 运 算 符 作 用 于 处 理 无 符 号 类 型 \\color\{\#FF7D00\}\{关于符号位如何处理并没有明确的规定，所以强烈建议仅将位运算符作用于处理无符号类型\} 关于符号位如何处理并没有明确的规定，所以强烈建议仅将位运算符作用于处理无符号类型

之前在处理输入和输出时，我们已经使用过标准IO库定义的<<和>>运算符的重载版本。这两种运算符内置含义是唯一操作。使用方法如下：

bit<<8;

关于位移等位操作由于机组中经常使用，便不展开解释。唯一注意区分位与（&）和逻辑与（&&）…

## 位移运算符满足左结合律 ##

cout<<"hello" << "world" <<endl;

# 九、sizeof运算符\[P139\] #

sizeof运算符返回一条表达式或者一个类型名字所占的字节数。sizeof运算符满足右结合律，其所得的值是一个size\_t类型的常量表达式。运算符的运算对象有两种形式：  
sizeof(type)  
sizeof expr  
在第二种形式中sizeof返回的是表达式结果类型的大小。与众不同的一点是，sizeof并不实际计算其运算对象的值：

Sales_data data, *p;
    sizeof(Sales_data);//存储Sales_data类型的对象所占的空间大小
    sizeof p;//指针所占的空间大小
    sizeof *p;//等价于sizeof(Sales_data);
    sizeof data.revenue;//Sales_data 的 revenue 成员对应类型的大小
    sizeof Sales_data::revenue;//和上面等价

sizeof \*p比较有意思。首先因为sizeof满足右结合律并且与\*运算符的优先级一样，所以表达式按照从右向左的顺序组合。  
C++11新标准允许我们使用作用域运算符来获取类成员的大小。通常情况下只有通过类的对象才能访问到类的成员，但是sizeof运算符无须我们提供一个具体的对象，因为要想知道类成员的大小无须真的获取该成员。  
一般的：  
对char类型运算结果为1  
对引用型类型执行，运算得到被引用对象所占的空间大小。  
对于指针类型执行，运算得到指针本身所占空间的大小。  
对于解引用指针执行sizeof运算得到指针指向的对象所占空间的大小，指针不需要有效。  
对数组执行sizeof运算得到整个数组所占空间大小，等价于对数组中所有元素各执行一次sizeof运算并将所得结果求和。注意，sizeof并不会把数组转换成指针来处理。  
注意：因为sizeof运算能得到整个数组的大小，所以可以用数组的大小除以单个元素的大小得到数组元素的个数：

constexpr size_t sz = sizeof(ia)/sizeof(*ia);
    int arr2[sz];//正确，sizeof返回一个常量表达式

因为sizeof返回的是一个常量表达式，所以我们可以用sizeof的结果声明数组的维度。

# 十、逗号运算符\[P140\] #

逗号运算符含义两个运算对象，按照从左向右的顺序依次求值。对于逗号运算符来说，首先对左侧的表达式求值，然后将求值结果丢弃掉。逗号运算符真正的结果是右侧表达式的值。如果右侧运算对象是左值，那么最终的求值结果也是左值。  
**逗号运算符经常被用在for循环当中**

# 十一、类型转换\[P141\] #

如果两种类型可以**相互转换**，则称他们是关联的，如

int ival = 3.541+3;//编译器会可能会警告该运算损失了精度

C++不会将两个不同类型的值相加，而是先根据类型转换规则设法将运算对象的类型统一后再求值。上述的类型转换是自动执行的，无须程序员介入，因此它们被称为**隐式转换**。  
算术类型之间的隐式转换被设计的尽量避免精度损失，以下几种情况可能会出现隐式转换：  
在大多数表达式中，比int小的整型值首先提升为较大的整数类型。  
在条件中，非bool转化为bool类型  
在初始化过程中，初始值转换成变量的类型；在赋值语句中，右侧运算对象转换成左侧运算对象的类型。  
如果算术运算或关系运算的运算对象有多种类型，需要转换成同一种类型。  
函数调用时会发生类型转换。

## 算术转换 ##

算术转换的含义是把一种算术类型转化成另一种算法类型，算术转换的规则定义了一套类型转换的层次，其中运算符的运算对象将转换成最宽的类型。例如，一个对象是long double另一个不管是什么类型都会转换为long double。

## 整型提升 ##

整型提升负责把小整数类型转换成较大的整数类型。对于bool、char、signed char、unsigned char、short、unsigned short等类型来说，只要它们所有可能的值都能存在int李，它们就会提升为int类型；否则提升为unsigned int 类型。就如我们所熟知的bool的false提升为0、true提升为1。  
较大的char类型（wchar\_t、char16\_t、char32\_t）提升成int、unsigned int、long、unsigned long、long long和unsigned long long中最小的一种类型，前提是转换后的类型要能容纳原类型所有的可能的值。  
 e x a m p l e 3 \\color\{\#0000FF\}\{example3\} example3：强制转换举例

bool fag;
    char cval;
    short sval;
    unsigned short usval;
    int ival;
    unsigned int uival;
    long lval;
    unsigned long ulval;
    float fval;
    double dval;
    3.14159L + 'a';//'a'提升为int，然后该int转为long double
    dval + ival;//ival转为double
    dval + fval;//fval转为double
    ival = dval;//dval切除小数部分转为int
    flag = dval;//dval如果是0则flag为flase，反之为true
    cval + fval;//cval提升为int，随后int转为float
    sval + cval;//sval和cval都提升为int
    cval + lval;//cval转换为long
    ival + ulval;//ival 转为unsigned long
    usval + ival;//根据unsigned short 和 int所占的空间大小进行提升
    uival + lval;//根据unsigned int 和 long 所占空间的大小进行转换

## 其他隐式类型转换 ##

除了算数转换之外还有几种隐式类型转换，包括以下几种：  
**数组转换成指针**:在大多数用到数组的表达式中，数组自动转换成指向数组首元素的指针：

int ia[100];
    int *ip = ia;//ia转换成指向数组首指针的元素

当数组被用作decltype关键字的参数，或者作为取地址符(&),sizeof,typeid等运算符的运算对象时，上述转换不会发生，同样的，如果用一个引用来初始化数组，上述转换也不会发生。  
**指针的转换**:C++还规定了几种其他的指针转换方式，包括常量整型值0或者字面值nullptr能转换成任意类型指针：指向任意非常量的指针能转换为void\*；指向任意对象的指针能转换成const void\*。  
**转换成bool类型**:存在一种从算数类型或指针类型向bool类型自动转换的机制。如果指针或算数类型的值为0，转换结果是false,否则则是true。

char *cp = get_string();
    if(cp)/*...*/ //指针cp不是0，条件为真
    while(*cp)/*...*/  //如果*cp不是空字符，条件为真

**类类型定义的转换**:类类型能定义由编译器自动执行的转换，不过编译器每次智能执行一种类类型的转换。（后续详谈）

## 显式转换 ##

有时候我们希望显式地将对象强制转换成另一种类型。例如，如果想在下面的代码中执行浮点数除法：

int i,j;
    double slope = i/j;

T I P 1 \\color\{\#FF0000\}\{TIP1\} TIP1：**虽然有时候不得不使用强制类型转换，但这种方法本质上是非常危险的**  
命名的强制类型转换具体形式如下：  
cast-name(expression)  
其中type是转换的目标类型，而expression是要转换的值。如果type是引用类型，则结果是左值。cast-name是static\_cast、dynamic\_cast、const\_cast和reinterpret\_cast中的一种。dynamic\_cast支持运行时类型识别。

static\_cast  
任何具有明确定义的类型转换，只要不包含底层const，都可以使用static\_cast，如：

double slope = static_cast<double>(j)/i；

static\_cast对于编译器无法自动执行的类型转换也非常有用。例如，我们可以使用static\_cast找回存在于void\*指针中的值：

void *p = &d;
    double *dp = static_cast<double*>p;

当我们把指针放在void\*中，并且使用static\_cast将其强制转换回原来的类型时，一你哥哥确保指针值不编。

const\_cast  
const\_cast只能改变底层运算对象的底层const

const char *pc;
    char *p = const_cast<char*>(pc);//正确，但是p写值是未定义的行为

对于将常量转换为非常量的行为，我们一般称为“去掉const性质”。一旦去掉了const性质，编译器就不再组织我们对该对象进行写操作了。只有const\_cast能改变表达式的常量属性，使用其他形式的命名强制类型转换改变表达式的常量属性都会引发编译器错误。

reinterpret\_cast（暂时没太懂）  
通常为运算对象的为模式提供较低层次上的重新解释。

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

我们必须牢记PC所指的真是对象是一个int而非一个字符，如果把pc当成普通的字符指针就会在运行中发生错误，如

string str(pc);