C++ Primer Plus学习笔记之处理数据

前言

个人觉得学习编程最有效的方法是阅读专业的书籍，通过阅读专业书籍可以构建更加系统化的知识体系。

一直以来都很想深入学习一下C++，将其作为自己的主力开发语言。现在为了完成自己这一直以来的心愿，准备认真学习《C++ Primer Plus》。

为了提高学习效率，在学习的过程中将通过发布学习笔记的方式，持续记录自己学习C++的过程。

本篇前言

本章首先将介绍C++的基本类型：整数和浮点数。同时会介绍一种标识存储的数据的方法——使用变量；接着介绍如何在C++中进行算术运算；最后，介绍C++如何将值从一种类型转换为另一种类型。

一、简单变量

为把信息存储在计算机中，程序必须记录3个基本属性：

• 信息将存储在哪里
• 要存储什么值;
• 存储何种类型的信息，

现在我们采用声明变量的方法来解决以上问题。当我们需要将商品的数量信息存储在计算机中时，可以通过如下代码实现：

int commodityCount;
commodityCount = 1000;
cout << "我们现在库存商品数量还有" << commodityCount <<"件" << endl;

通过上述2条语句告诉程序，它正在存储整数，并使用名称 commodityCount来表示该整数的值为1000。

能完成以上功能，是因为程序将在内存中找到一块能够存储整数的内存，并将该内存单元标记为commodityCount，同时将值1000复制到该内存单元中；然后，我们才可以通过commodityCount来访问该内存单元。

1、变量名

C++提倡使用有一定含义的变量名。如存储商品数量是建议使用使用类似commodityCount这类有含义的变量名，而不是随意使用a、b、c、x等与变量意义相差较大的变量名。

必须遵循几种简单的C++命名规则：

• 在名称中只能使用字母字符、数字和下划线（_）
• 名称的第一个字符不能是数字
• 区分大写字符与小写字符
• 不能将C++关键字用作名称
• 以两个下划线打头或以下划线和大写字母打头的名称被保留给实现(编译器及其使用的资源)使用。以一个下划线开头的名称被保留给实现，用作全局标识符。
• C++对于名称的长度设有限制，名称中所有的字符都有意义，但有些平台有长度限制

具体示例如下：

int commodityCount;//有效
int CommodityCount;//有效，同时与第一个变量名不同
int COMMODITYCOUNT;//有效，同时与第一、第二个变量名不同
Int commodityCount;//无效，变量类型应为int而是不Int
int my_commodityCount;//有效
int _MycommodityCount;//有效，但以下划线和大写字母打头的名称被保留给实现(编译器及其使用的资源)使用
int double;//无效，变量名double是C++的关键字之一
int begin;//有效，但begin是Pascal(结构化编程语言) 的关键字
int __commodityCount;//有效，以两个下划线打头或以下划线和大写字母打头的名称被保留给实现(编译器及其使用的资源)使用
int the_very_best_variable_i_can_be_version_112;//有效
int commodity-Count;//无效，在名称中只能使用字母字符、数字和下划线（_）

如果想用两个或更多的单词组成一个名称，通常的做法是用下划线字符将单词分开或者采用驼峰命名法（除了第一个单词以外,其他单词的第一个首字母都为大写状态）。

2、整型

整数就是没有小数部分的数字，如1、99、-500和0。

不同C++整型使用不同的内存量来存储整数，以便根据程序的具体要求选择最合适的整型。使用的内存量越大，可以表示的整数值范围也越大。术语宽度（width）用于描述存储整数时使用的内存量。使用的内存越多，则越宽。另外，根据类型有无符号，可同时表示正值和负值或只能表示正值。

C++的基本整型（按宽度递增的顺序排列）分别是char、short、int、long和C++11新增的long long，其中每种类型都有符号和无符号版本，因此总共有 10种类型可供选择。下面更详细地介绍这些整数类型。由于char类型有一些特殊属性（它最常用来表示字符，而不是数字），因此将首先介绍其他类型。

64位操作系统中整型类型所占大小如下表：

序号	类型	所占字节数	表示范围
1	char	1	-128~127
2	unsigned char	1	0~255
3	short	2	-32,768~32,767
4	unsigned short	2	0~65,535
5	int	4	-2,147,483,648~2,147,483,647
6	unsigned int	4	0~4,294,967,295
7	long	4	-2,147,483,648~2,147,483,647
9	unsigned long	4	0~4,294,967,295
10	long long	8	-9,223,372,036,854,775,808~9,223,372,036,854,775,807
11	unsigned long long	8	0~18,446,744,073,709,551,615

3、整型short、int、long和long long

计算机内存由一些叫作位（bit）的单元组成。C++的short、int、long和long long类型通过使用不同数目的位来存储值、最多能够表示4种不同的整数宽度。

提示：实际上short是short int的简称，long是long int的简称。

C++的整型在不同位数操作系统所占位数存在差异，因此C++提供了一种灵活的标准，它确保了最小长度（从C语言借鉴而来），如下所示：

• short至少16位
• int至少与short一样长
• long至少32位，且至少与证int一样长
• long long至少64位，且至少与long一样长。

位与字节:

计算机内存的基本单元是位（bit）。可以将位看作电子开关，可以开，也可以关。关表示值0，开表示值1。8位的内存块可以设置出256种不同的组合，因为每一位都可以有两种设置，所以8位的总组合数为2×2×2×2×2×2×2×2，即256种。因此，8位单元可以表示0_{255或者-128}127。每增加一位，组合数便加倍。

字节（byte）通常指的是8位的内存单元。从这个意义上说，字节指的就是描述计算机内存量的度量单位，1KB等于1024字节。然而，C++对字节的定义与此不同。C++字节由至少能够容纳实现的基本字将集的相邻位组成，也就是说，可能取值的数目必须等于或超过字符数目。如中文需要使用2个字节即16位字节。

通常，在老式IBMPC的实现中，int的宽度为16位（与short相同），而在Windows XP、Windows vista、Wndows 7、Macimlosh OS X、VAX和很多其他微型计算机的实现中，为32位（与long相同）。

要知道系统中整数的最大长度，可以在程序中使用C++工具来检查类型的长度。首先，sizeof运算符返回类型或变量的长度，单位为字节（运算符是内置的语言元素，对一个或多个数据进行运算，并生成一个值。例如，加号运算符+将两个值相加）。前面说过，“字节”的含义依赖于实现，因此在一个系统中两字节的int可能是16位,而在另一个系统中可能是32位。其次，头文件climits（在老式实现中为limits.h）中包含了关于整型限制的信息。具体地说，它定义了表示各种限制的符号名称。例如，INT_MAX为 int的最大取值，CHAR_BIT为字节的位数。下面我们将通过程序介绍如何使用这些工具，以及如何初始化，即使用声明语句将值赋给变量。

程序清单3.1：

// limits.cpp -- 部分整型限制
#include <iostream>
#include <climits>
int main()
{
    using namespace std;
    int n_int = INT_MAX; // 初始化n_int为最大int值
    short n_short = SHRT_MAX; // SHRT_MAX是在<climits>文件中定义的符号
    long n_long = LONG_MAX;
    long long n_llong = LLONG_MAX;
    // 使用sizeof运算符计算类型或变量的大小
    cout << "int is " << sizeof (int) << " bytes." << endl;
    cout << "short is " << sizeof n_short << " bytes." << endl;
    cout << "long is " << sizeof n_long << " bytes." << endl;
    cout << "long long is " << sizeof n_llong << " bytes." << endl;
    cout << endl;
    cout << "最大值：" << endl;
    cout << "int: " << n_int << endl;
    cout << "short: " << n_short << endl;
    cout << "long: " << n_long << endl;
    cout << "long long: " << n_llong << endl << endl;
    cout << "Minimum int value = " << INT_MIN << endl;
    cout << "Bits per byte = " << CHAR_BIT << endl;
    return 0;
}

博主的环境运行结果如下（Windows10 64位）：

int is 4 bytes.
short is 2 bytes.
long is 4 bytes.
long long is 8 bytes.
最大值：
int: 2147483647
short: 32767
long: 2147483647
long long: 9223372036854775807
Minimum int value = -2147483648
Bits per byte = 8

（1）运算符sizeof和头文件limits

sizeof运算符指出，在使用8位字节的系统中，int的长度为4个字节。使用sizeof计算类型长度时，应将名称放在括号中；但对变量名(如int)计算类型长度时，括号是可选的，代码如下：

cout << "int is " << sizeof (int) << " bytes." << endl;
cout << "int is " << sizeof n_int << " bytes." << endl;

头文件climies定义了符号常量来表示类型的限制，具体如下表：

序号	符号常量	表示
1	CHAR_BIT	char的位数
2	CHAR_MAX	char的最大值
3	CHAR_MIN	char的最小值
4	SCHAR_MAX	signed char的最大值
5	SCHAR_MIN	signed char的最小值
6	UCHAR_MAX	unsigned char 的最大值
7	SHRT_MAX	short的最大值
8	SHRT_MIN	short的最小值
9	USHRT_MAX	unsigned short的最大值
10	INT_MAX	int的最大值
11	INT_MIN	int的最小值
12	UINT_MAX	usigned int的最大值
13	LONG_MAX	Iong的最大值
14	LONG_MIN	long的最小值
15	ULONG_MAX	unsigned long的最大值
16	LLONG_MAX	long long的最大值
17	LLONG_MIN	long long的最小值
18	ULLONG_MAX	unsigned long long的最大值

在climits文件中包含与下面类似的语句行：

#define INT_MAX 32767

在C++编译过程中，首先将源代码传递给预处理器。#define编译指令的工作方式与文本编辑器或字处理器中的全局搜索并替换命令相似。C++可以使用const关键字声明常量，替换#define编译指令的作用。但如果要考虑C语言的兼容性，则还是需要使用#define编译指令。

（2）初始化

初始化可以将赋值与声明合并在一起。示例代码如下：

int n_int = INT_MAX;
int commodityCount = 1000;
int sum = commodityCount + 1;

除了以上继承自C语言的初始化语法，还有一种C++特有的初始化语法，代码如下：

int todayStockOutCount(20);

（3）C++11初始化方式

还有另一种初始化方式，这种方式用于数组和结构，但在C++98 中，也可用于单值变量，代码如下：

int todayStockOutCount = {20};

采用以上初始化方式，可以将=忽略，代码如下：

int todayStockOutCount  {20};

大括号中间没有任何值是，变量todayStockOutCount将被初始化为零。

通过大括号初始化器（可以使用等号也可以不使用），统一了C++11中任何类型的初始化都得到了。

4、无符号类型

前面介绍的4种整型都有一种不能存储负数值的无符号变体，其优点是可以增大变量能够存储的最大。例如，如果short表示的范围为-32768到+32767，则无符号版本的表示范围为0-65535。要创建无符号版本的基本整型，只需使用关键字unsigned来修改声明，代码如下：

unsigned int commodityCount;

C++确保了无符号类型的这种行为；但C++并不保证符号整型超越限制（上溢和下溢）时不出错，而这正是当前实现中最为常见的行为。

5、选择整型类型

C++提供了大量的整型，应使用哪种类型呢？通常，int被设置目标计算机处理起来效率最高的长度。如果没有非常有说服力的理由来选择其他类型，则应使用int。

6、整型字面值

C++能够以三种不同的计数方式来书写整数：基数10、基数8和基数16，C++使用前一到两位来标识数字常量的基数，下面我们将介绍分别在C++中的表示方法：

• 基数10（十进制数）：第一位为1~9
• 基数8（八进制数）：第一位为0，第二位为1~7
• 基数16（十六进制数）：第一位为0，第二位为小写x或大写X，字符a_f和AF对应于10~15

提示：无论何总基数，最终都将以相同的方式存储在计算机中被存储为二进制数（以2为基数）。

7、如何确定常量的类型

编译器是如何知道常量的类型呢？答案是、除非有理由存储为其他类型(如使用了特殊的后缀来表示特定的类型，或者值太大，不能存储为int)，否则C++将整型常量存储为int类型。

类型对应后缀如下表：

序号	类型	后缀
1	unsigned int	u或U
2	long	l或L
3	unsigned long	ul（任意顺序、大小写均可）
4	long long	ll或LL
5	unsigned long long	ull、Ull、uLL、ULL

8、char类型：字符和小整数

顾名思义，char类型是专为存储宇符 （如字母和数字）而设计的。很多系统支持的字符都不超过128个，因此用一个宇节就可以表示所有的符号。

在美国，最常用的符号集是 ASCII字符集，其中字符A的编码为65，字母M的编码为77。具体可查看以下代码：

// chartype.cpp -- char类型
#include <iostream>
int main()
{
    using namespace std;
    char ch; // 声明一个char变量
    cout << "输入字符: " << endl;
    cin >> ch;
    cout << "你好！";
    cout << "感谢 " << ch << "（" << (int)ch << "）字符。" << endl;
    return 0;
}

运行结果如下：

输入字符:
M
你好！感谢 M（77）字符。

程序中输入的是M，输出的是M，编码77还需要转换为int类型。是因为输人时，cin将键盘输人的M转换为77;输出时，cout将值77转换为所显示的字符M；cin和cout的行为都是由变量类型引导的。

在C++中，书写字符常量的方式有多种。对于常规字符（如字母、标点符号和数字），最简单的方法是将字符用单引号括起。这种表示法代表的是字符的效值编码。例如：'A'为65，即字符A的ASCII码。

有些字符不能直接通过键盘输人到程序中。对于这些字符，C++提供了一种特殊的表示方法——转义序列，如下表所示：

序号	字符名称	ASCII符号	C++代码	十进制ASCII码	十六进制ASCII码
1	换行符	NL(LF)	\n	10	0xA
2	水平制表符	HT	\t	9	0x9
3	垂直制表符	VT	\v	11	0xB
4	退格	BS	\b	8	0x8
5	回车	CR	\r	13	0xD
6	振铃	BEL	\a	7	0x7
7	反斜杠	\	\	92	0x5C
8	问号	?	?	63	0x3F
9	单引号	’	’	39	0x27
10	双引号	"	"	34	0x22

注意：

• 应该像处理常规字符 (如M) 那样处理转义序列 (如\n)。也就是说，将它们作为字符常量时应用单引号括起；将它们放在字符串中时，不要使用单引号。现代系统并非都支持所有的转义序列，如输人振铃字符时，有些系统不会有反馈。
• 数字转义序列与特定的编码方式（如ASCII码）相关，建议使用适用于任何编码方式的符号转义序列表示，其可读性也更强。

C++实现支持一个基本的源字符集，即可用来编写源代码的字符集。通用字符名的用法类似于转义字符。通用字符名可以以\u或\U打头。\u后面是4个十六进制位，\U后面则是8个十六进制位。这些位表示的是字符的ISO 10646码点（编码字符集委员会发布，用来实现全球所有文种的统一编码 ）。请注意，C++使用术语“通用编码名”，而不是“通用编码"，这是因为应将\u00F6 解释为“Unicode码点为U-00F6 的字符”。

如果将 char用作数值类型，则unsigned char和char之间的差异将非常重要。

程序需要处理的字符集可能无法用一个8位的字节表示，如汉字系统。C++有两种处理方式：

1. 如果大型字符集是实现的基本字符集，则编译器厂商可以将char定义为一个16位的字节或更长的字节。
2. 一种实现可以同时支持一个小型基本字符集和一个较大的扩展字符集。8 位char 可以表示基本字符架，另一种类型wchar_t （宽字符类型）可以表示扩展字符集。

wchar_t 类型是一种整数类型，与另一种整型(底层[underlying]类型) 的长度和符号属性相同，它有足够的空间，可以表示系统使用的最大扩展字符集。这种类型依赖实现，因此在一个系统中，它可能是unsigned short，而在另一个系统中，则可能是int。iosteam头文件的最新版本提供了作用相似的工具wcin和wcout，可用于处理wchar_t流。另外，可以通过加上前缀L来指示宽字符常量和宽宇符串。

为了避免wchar_t类型随实现而异带来的影响，C++11新增了类型：char16_t和char32_t，两个类型均无符号，前者长为16位、使用前缀u、与\u00F6的通配字符名匹配，后者长32位。、使用前缀U、与\U0000222B的通配字符名匹配。

9、bool类型

bool类型名称来源于英国数学家Gcorge Boole，是他开发了逻辑律的数学表示法。

在计算中，布尔变量的值可以是 true或false。C++将非零值解释为 true，将零解释为false。示例如下：

• int readyStatusCode = is_ready;，readyStatusCode值为1
• bool is_start = 100;，因为100位非零，所以is_start为true
• bool is_end = 0;，因为C++将零解释为false，所以is_end为false

二、const限定符

前面提到：

C++可以使用const关键字声明常量，替换#define编译指令的作用。
关键字const叫作限定符，因为它限定了声明的含义。

通过使用const关键字，声明一个符号常量Months表示月份数的，代码如下：

const int Months = 12;

常量（如Months） 被初始化后，其值就被固定了，编译器将不允许再修改该常量值。

常见命名规则：通过将常量名首字母大写，来提醒这是一个常量。

const优于#define的地方有3点分别是：能够明确类型；可以使用C++的作用域规则将定义限制在特定的函数或文件中；可以将const用于更复杂的类型，如后面将涉及的数组。

三、浮点数

浮点类型，是C++的第二组基本类型。浮点数能够表示带小数部分的数字，提供的值范围也更大。

计算机将浮点值分成两部分存储。一部分表示值，另一部分用于对值进行放大或缩小。对于数字34.1245 和34124.5，它们除了小数点的位置不同外，共他都是相同的。可以把第一个数表示为0.341245（基准值）和100（缩放因子），而将第二个数表示为0.341245（基准值相同）和10000（缩放因子更大）。缩放因子的作用是移动小数点的位置，术语浮点因此而得名。C++内部表示浮点数的方法与此相同，只不过它基于的是二进制数，因此缩放困子是2的幂，不是10的幂。

1、书写浮点数

C++有两种书写浮点数的方式：

• 第一种是使用常用的标准小数点表示法，如12.34
• 第二种表示浮点值的方法叫作E表示法，其外观是像这样的：3.45E63，表示的是3450000，6被称为指数，3.45被称为尾数。指数为负数意味着除以10的乘方，而不是乘以10的乘方。因此，8.33E4表示的是0.000833。d.dddE+n指的是小数点向右移动n位，d.dddE-n指的是小数点向左移动n位。之所以称为“浮点”，就是因为小数点可移动。

2、浮点类型

C++也有3种浮点类型: float、 double和long double。这些类型是按它们可以表示的有效数位和允许的指数最小范围来描述的。有效位(significant figure) 是数字中有意义的位。

C++对于有效位数的要求是，float至少32位，double至少48位，且不少于float，long double至少和double一样多。这三种类型的有效位数可以一样多。然而，通常，float为32位，double为64位，long double为80、96或128位，另外，这3种类型的指数范围至少是-37到37。可以从头文件cfloat或float.h中找到系统的限制（部分C++实现没有）。

下面我们将演示了一下float和double类型及它们表示数字时在精度方面的差异 （即有效位数）。具体代码如下：

// floatnum.cpp -- 浮点类型
#include <iostream>
int main()
{
    using namespace std;
    cout.setf(ios_base::fixed, ios_base::floatfield); // 设置`cout`为定点输出格式，输出时按浮点格式，小数点后有6位数字
    float tub = 10.0 / 3.0;
    double mint = 10.0 / 3.0;
    const float million = 1.0e15;
    cout << "tub = " << tub;
    cout << ", a million tubs = " << million * tub;
    cout << ",\nand ten million tubs = ";
    cout << 10 * million * tub << endl;
    cout << "mint = " << mint << " and a million mints = ";
    cout << million * mint << endl;
    return 0;
}

运行结果如下：

tub = 3.333333, a million tubs = 3333333.250000,
and ten million tubs = 33333332.000000
mint = 3.333333 and a million mints = 3333333.333333

通常cout会删除结尾的零。例如，将3333333.250000 显示为3333333.25。调用cout.setf()将覆盖这种行为（其中ios_base::fixed是设置cout为定点输出格式，ios_base::floatfield是设置输出时按浮点格式，小数点后有6位数字）。

这里要注意的是，为何float的精度比double低，tub和mint都被初始化为10.0/3.0——3.333333333333333333由于cout打印 6 位小数，因此tub和mint都是精确的但当程序将每个数乘以一百万后，tub在第7个3之后就与正确的值有了误差。tub在7位有效位上还是精确的 （该系统确保float至少有6位有效位，但这是最糟糕的情况）。然而，double类型的变量显示了13个3，因此它至少有13位是精确的。由于系统确保15位有效位，因此这就没有什么好奇怪的了。另外，将tub乘以一百万，再乘以10后，得到的结果不正确，这再一次指出了float的精度限制。

3、浮点常量

默认情况下，在程序中书写浮点常量的时候，像8.24和2.4E8
这样的浮点常量都属于double类型。如果希望常量为float类型或long double类类型，可以通过后缀进行明确。后缀如下表：

序号	类型	后缀	示例
1	double	默认无后缀	3.333或9.11e-31
2	float	f或F	3.333f或3.333F
3	long double	l或L	3.333l或3.333L

4、浮点数的优缺点

与整数相比，浮点数有两大优点：

1. 它们可以表示整数之间的值
2. 由于有缩放因子，它们可以表示的范围大得多

浮点数的缺点则是浮点运算的速度通常比整数运算慢，且精度将降低。具体见以下代码：

// fltadd.cpp -- 浮点数的精度问题
#include <iostream>
int main()
{
    using namespace std;
    float a = 2.34E+22f;
    float b = a + 1.0f;
    cout << "a = " << a << endl;
    cout << "b - a = " << b - a << endl;
    // cin.get();
    return 0;
}

运行结果如下：

a = 2.34e+22
b - a = 0

按照程序逻辑理解，b - a的结果应该不为0，但实际上在计算机中受限于float类型的精度问题，在a为23位数字的基础上加1，对这个值不会有任何影响。

4、C++算术运算符

下面是C++提供的5种基本算术运算符：

• 运算符+对操作数执行加法运算。例如，4+20等于24。
• 运算符-从第一个数中减去第二个数。例如，12-3等于9。
• 运算符*将操作数相乘。例如，28*4等于112。
• 运算符/用第一个数除以第二个数。例如，1000/65 等于200。如果两个操作数都是整数，则结果为商的整数部分。例如，173等于5，小数部分被丢弃。
• 运算符%求模。也就是说，它生成第一个数除以第二个数后的余数。例如，19%6 为1，因为19是6的3倍余1。两个操作数必须都是整型，将该运算符用于浮点数将导致编译错误。如果其中一个是负数，则结果的符号满足如下规则: (a/b)*b+a%b = a。

（1）运算符优先级和结合性

当多个运算符可用于同一个操作数时，C++使用优先级规则来决定首先使用那个运算符。算术运算符遵循通常的代数优先级，先乘除，后加减。当然，可以使用括号来执行自己定义的优先级。

C++将看操作数的结合性 (associntivity ) 是从左到右，还是从右到左。当两个运算符的优先级相同时，乘除都是从左到右结合的。

注意：仅当两个运算符被用于同一个操作数时，优先级和结合性规则才有效。所以存在规则未明确的计算顺序，需要根据具体实现来看。这种情况下建议使用括号来明确定义优先级。

（2）除法分支

除法运算符（/）的行为取决于操作数的类型。如果两个操作数都是整数，则C++将执行整数除法。这意味着结果的小数部分将被丢弃，使得最后的结果是一个整数。如果其中有一个（或两个）操作数是浮点值，则小数部分将保留，结果为浮点数。

（3）求模运算符

求模运算符%返回整教除法的余数。它与数除法相结合，尤其适用于解决要求将一个量分成不同的整数单元的问题，例如将月份数量转换为年数。

（4）类型转换

C++丰富的类型允许根据需求选择不同的类型，这也使计算机的操作更复杂。为处理这种潜在的混乱。C++自动执行很多类型转换：

• 将一种算术类型的值赋给另一种算术类型的变量时，C++将对值进行转换
• 表达式中包含不同的类型时，C++将对值进行转换
• 将参数传递给函数时，C++将对值进行转换

编译器通过校验表来确定在算术表达式中执行的转换，下面是C++11 版本的校验表，编译器将依次查阅该列表：

1. 如果有一个操作数的类型是long double，则将另一个操作数转换为long double。
2. 否则，如果有一个操作数的类型是double，则将另一个操作数转换为double。
3. 否则，如果有一个操作数的类型是float，则将另一个操作数转换为float。
4. 否则，说明操作数都是整型，因此执行整型提升。
5. 在这种情况下，如果两个操作数都是有符号或无符号的，且其中一个操作数的级别比另一个低则转换为级别高的类型。
6. 如果一个操作数为有符号的，另一个操作数为无符号的，且无符号操作数的级别比有符号操作数高，则将有符号操作数转换为无符号操作数所属的类型。
7. 否则，如果有符号类型可表示无符号类型的所有可能取值，则将无符号操作数转换为有符号操作数所属的类型。
8. 否则，将两个操作数都转换为有符号类型的无符号版本。

整型级别：

• 有符号整型按级别从高到低依次为long long、long、
  int、short和signed char。
• 无符号整型的排列顺序与有符号整型相同。
• 类型char、signed char和unsigned char的级别相同。
• 类型bool的级别最低。
• wchar_t、char16_t和char32_t的级别与其底层类型相同。

类型转换：
C++允许通过强制类型转换机制显式地进行类型转换，强制转换有两种通用格式如下：

(typeName)value
typeName(value)

第一种继承自C语言，第二种格式是C++格式，新格式的想法是、要让强制类型转换就像是函数调用。

（5）C++中的auto声明

C++11新增了一个工具，让编译器能够根据初始值的类型推断变量的类型。为此，它重新定义了auto的含义。示例如下：

int commodityCount = 1000;
auto commodityCount = 1000;

以上两句代码都表示声明了一个int类型名为commodityCount的变量。

但其实auto声明的自动类型推断，在处理复杂类型，如标准模块库（STL）中的类型时，优势才能显现出来。