C++ Primer 笔记 第二章

---

在 C++ 中，基础类型（Primitive types）包括算数类型（Arithmetic types）和一种特殊的类型 void。 Void 类型主要适用与无返回值的函数。

在C++中, 整型（Integral）和浮点型（ Floating-point） 统称算术类型。而整型又分为3种类型：integers ， boolean 和 char.

1. bool, 存放 true or False
2. char, 存放字符，C++ 中有比标准 char 大一倍的 wchar_t，有适用于 Unicode 的 char16_t / char32_t。
3. int, 存放整数，有 short / int / long / long long 适应不同大小的数。

对于所有 Integral 类型的变量来说，除开 bool 类型，int 和 char 都可以带有符号或者不带有符号。跟 int 不同, char 有三种类型： char, signed char, unsigned char.

unsigned 类型的所有位数都用于存储值，因此一般来说范围是从 0 开始。signed 类型由于需要多出一位记录正负，因此能表达的数值范围会以 0 为中心点。

1. unsigned 类型请使用非负值赋值。
2. 对整型操作中，int 会比 short 类型使用起来更方便。
3. 不要将 bool 和 char 用于算术表达式中。 带符号的 char 类型会在不同的系统里表达出不同的正负。如果非要使用请指定正负。
4. 浮点数运算请使用 double。double 的精度更高，在现代计算机上有时候速度反而比 float 快。

• nobool → bool : 0 = False, 其他值 = True
• bool → nobool(算数类型) : False = 0, True = 1

• float-point → intergral types: value truncated，保留小数点之前的部分。
• intergral types → float-point: 小数部分记 0，如果整数占用 bits 大于浮点数，精度可能会丢失。

• 超过范围的值 → unsigned 类型: 求模运算。比如：unsigned char c = -1; -1+256 = 255; 所以 c 值应该等于 255.
• 超过范围的值 → signed 类型: undefined.

如果进行 unsigned+singed 运算，结果将会被转换为 unsigned 类型。也就是说，如果结果为负数，会进行取模运算。

字面值常量（Literals） 实际上指值不变的变量，也就是常量。字面值常量的类型和值决定了它自身的数据类型。

整型和浮点型的字面值可以写成十进制（decimal）、八进制（octal）或者十六进制（hexdecimal）的形式，比如：

20 decimal //signed by default
024 octal //start with 0
0x14 hexadeicmal //start with 0x

当本类型常量为八进制或者十进制的时候，其数据类型为最小的可以容纳下该数据的类型（比如 int 能容纳下，就是 int，否则就尝试 long，以此类推）。

技术上来说，十进制下的常量不会为负值。也就是说，符号不包含在字面值常量中，而是一种对字面值常量取负的运算。

浮点型的字面值为小数，可以由科学计数法的小数表示。

• 字符 / 字符串的字面值由单引号 / 双引号之间的内容表示。
• 字符串比看上去的字面值长度要大 1，因为编译器会在字符串末尾加 \0 作为结束的标记。
• 如果字符串之间仅由空格、缩进、换行符分割，那么实际上他们是一个整体。

Ref:ecsape sequences

转义序列（ecsape sequences）指需要打印（不可打印字符或特殊字符）时需要用到的命令，比如 \n 等等。所有的这些命令必须要使用 \ 开头才能生效。

也被称为 generalized escape sequence。该序列通过两种组合方式来表现不同的不可打印字符（总之就是用数字来表示对应的字符）：

• 以 \x 起头，后面接 1 位或者更多位的十六进制数，比如 \x4d
• 以 \ 起头，后面接 1位或者更多位数的八进制数，比如 \115

上面的数对应了字符的字符值（ascii 值，简单的对照表）

变量被存储于计算机里，可以被计算机做修改操作。C++ 中变量的一般包括变量( Variables )和对象( Objects )

在C++中，变量的定义（ Definition ）与声明（Declaration ）是分开的。C++ 在编译的过程中是支持分别编译（ Separate Compliation） 的。为了支持这种行为，C++ 严格区分了定义和声明。声明指定了变量的名字，而定义建立了与之名字对应的实体(分配存储空间，赋予初始值)。 所以，任何带有初始值的声明，都是定义。

因此，我们通过在一个文件中定义一个对象(变量)，然后在其他文件中需要使用的时候声明便可以使用了。正常的使用流程是，首先做出定义（存到指定的 header），然后在到需要使用的地方声明一遍即可。

如果希望只声明而不定义变量，可以使用 extern 关键字。有两点要注意：

• 如果在含有 extern 的声明中进行了赋值初始化，那么表达式就会从声明转化为定义，extern 的功能将会被覆盖。
• extern 不能用于函数内部。

extern int i; //declaration but not definition 
extern int i = 10; //definition, extern has been overridden.

在C++中，初始化和赋值是两个完全不同的概念。初始化发生在对象创建的时候，而赋值是替换已存在对象的值。

C++提供了4种形式的整形变量初始化：

int a = 0; // expression
char c = {'x'}; // { initializer-list }
int b{0}; // { initializer-list }
char d('y'); // ( expression-list )

其中带 curly braces 的初始化形式是新标准, 称之为 List Initialization。 C++ Primer 的作者推荐使用这种形式。原因是 List 初始化自带类型校验：List 初始化不允许类型转换 (Type Conversion) 带来的 Narrowing Conversion。比如：

double x = 3.1415926;
int a{x}; // error: narrowing conversion
int b(x), c = x; //ok: b and c are truncated

如果在初始化的时候没有制定初始化的值，那么编译器就会对变量做默认初始化( Default Initialization )。默认初始化的值跟以下两点有关系：

1. 对象初始化的位置：算术类型定义在函数外部的，默认值为 0，定义在函数内部的，会导致 undefined。
2. 对象的类型: 上述的规则是针对于 Build-inType 和没有定义默认初始化的自定义类型来说的。如果自定义类型（比如类）中有默认构造函数进行初始化，那么该类型的默认初始化值就是该类型定义的初始值。

总的来说，Identifiers 指广义范围内变量 / 对象的名字。Identifiers 有几个特性：

• 必须以字母（letters）或者下划线（underscore）开头。
• 区分大小写。
• 不能与系统保留的关键字重名。

一些约定俗成的规矩：

• Identifiers 需要表意
• variable Identifiers 一般情况下小写
• class Identifiers 一般开头大写
• 较长的 Identifiers 使用下划线或者骆驼写法区分，比如 student_loan 或者 studentLoan。

如果希望同一个 name 对应不同的实体，可以使用 Scope 实现。通过在指定的 scope 内声明变量，就可以在指定的作用域内绑定name 与实体。作用域为的 scope 的范围，其通过 curly brace来指定。有几个例子：

• main{}，自身就是一个 scope。这种定义在所有 scope 外部的 scope，称之为 Global Scope。只要程序正在运行，该类 scope 就会一直存在。
• 在 scope 中定义的变量，其作用域范围从其被看见（声明）的位置开始直到该 scope 结束。这种变量具有 block scope。

scope 是可以嵌套的。外部的被称为 outter scope，内部的则被称为 inner scope。通常情况下：

• outter scope 定义的变量可以被 Inner scope 使用
• inner scope 可以定义与 outter scope 名字相同的变量，并重新定义，也就是就近使用

如果在 inner scope 已经做了与外部变量重名的定义，但又要使用外部重名的变量，可以使用 Scope operator :: 调用外部变量：

#include <iostream>
int reused = 42;
int main(int argc, char const *argv[])
{
	std::cout << reused << std::endl; //print the outter reused, the 42
	int reused = 0;
	std::cout << reused << std::endl; //print the inner reused, the 0, outter definition overwrited
	std::cout << ::reused << std::endl; //print the outter reused, the 42, explictly accesss the outter variable

	return 0;
}

复合类型（ Compound Type ）是指基于某种指定的类型而定义下来的类型。C++ 中 比较重要的复合类型有：指针（Pointer )、引用（Reference）。

引用定义了一个对象的别名（Alternative Name）。我们可以把引用的定义看做是一种绑定（bind）。因此在定义引用的时候，必须对引用进行初始化。比如：

int ival = 1024; //object will be bind.
int &refVal =ival; //a reference will bind to ival
int &refVal2; // error: no binding object, reference must be initialized.

我们用符号 & 来定义引用。引用的定义方法如下：

int i = 1024, i2 = 2048; //two int objects that will be used for bind
int &r = i; &r2 = i2; // r是i的引用，r2是i2的引用。

1. 引用必须指向一个对象（必须用对象来初始化 / 必须绑定对象），literal 不能直接引用。
2. 引用自身不是对象，是别名（所以不存在引用的引用）。
3. 引用的类型必须和被引用的对象类型一致。

指针（Pointer）与引用类似，也是通过间接方式访问对象（通过地址）。但是指针跟引用不同在于，指针本身自己是个对象。所以，指针具有对象（变量）的一切性质：可访问，可赋值，等等。 相较于引用，指针拥有以下特性：

• 可以被赋值和复制
• 可以改变指向的内存位置
• 定义的时候不需要被初始化（不用绑定已存在对象）

Ref:What are the differences between a pointer variable and a reference variable in C++?

指针变量的定义使用 * 符号进行定义。同时，指针是用于存储内存地址的对象，所以指针的初始化值必须是一个地址。我们用 & （在定义中是引用，在运算中是取地址操作符）来得到对象的地址，那么指针的一般初始化形式就应该是:

int i = 1;
int *p = &i; //store the address of i in pointer p

同时定义几个指针的时候，每个指针前面必须加上 * 号，例如：

int *p1, *p2;

需要注意的是：

• 引用自身并没有地址，因此不能创建一个指向引用的指针.
• 指针在 initialization / assignment 的时候，类型必须与所处指向地址的数据类型相同（指向不同的类型，或者指向指向该类型的指针，都是不行的。）

double dval;
double *pd = &dval; // ok: initializer is the address of a double, address to address
double *pd2 = pd; // ok: initializer is a pointer to double, address to address
int *pi = pd; // error: types of pi and pd differ
pi = &dval; // error: a pointer pointed to double can't assign to an int pointer

• 第一类，指向某个对象
• 第二类，指向某个位置，该位置正好在某个对象占用空间的下个地址格
• 第三类，不指向任何对象，也就是空指针
• 除以上三种，都是无效指针（对此类型指针操作都将导致 undefined 行为）

需要注意的是，访问所有没有指向明确对象的指针都属于 undefined 行为。

*，在运算中被称为解引用运算符（Dereference Operator）。我们使用该运算符来获取指针指向的对象中的内容：

int ival = 42;
int *p = &ival; // 这里的 * 是定义，是定义指针的标识，不是解引用。这里的 & 是运算，是取对象地址的运算，不是定义引用的标识。
cout << *p; // 这里的 * 是运算，是解引用，是将指针指向的对象中的内容取出。

• 定义下的用法（Type modifier）：
  • * 用于定义指针，int *p; 这里的 * 代表 p 是一个指针。
  • & 用于定义引用：int &r = i;。这里的 & 代表 r 是绑定到 i 的引用。
• 运算下的用法
  • 访问指针/引用指向的元素的时候（Derefenece）： *p = i; 。这里的 * 是解引用运算符。
  • 取地址的时候：p = &i;。 这里 & 代表取 i 的地址。

总的来说，就是在声明的时候，& 和 * 都是用于定义复合类型的。在表达式中，这两个符号都是运算符（* 还可以用作乘法运算），一个是解引用（访问地址中的内容） 一个是 取地址（访问指针中的地址值）。

如果定义指针的时候不明确指向对象，我们可以用到 null 指针。null 指针不指向任何地方，只是用来初始化。在C++11中，作者推荐用 nullptr 来取代 NULL （C 语言中 cstdlib）对空指针进行初始化。

为什么在C++中使用 nullptr 取代 NULL 可以参考这篇文章： C++11中的 nullptr 详解

对指针的赋值和对引用的赋值是不同的。引用一旦绑定，就不可能再进行引用对象的更改，任何对引用的操作都是对其初始对象的操作。指针则不同，指针是可以通过赋值来改变指向位置的：

int i =42;
int *pi = 0; //initialize pointer pi as a null pointer.
int *pi2 = &i; //initialize pi2 as a pointer points to the addresss of i
int *pi3; //bad pratice, pi3 would be uninitialized if it is not a global pointer
pi3 = pi2; // pi3 and pi2 point to the same address
pi2 = 0; // pi2 points is null pointer now.

一个通用的规则是，赋值改变的是赋值运算符左边算子的内容。这个算子是指的一个整体。比如：

pi = &ival; //改变的是 pi 的内容

那么如果是如下形式：

*pi = 0; //改变的是 pi 指向的内容

由于这里是赋值运算，那么左边的 * 被视作解引用运算符，左边整体可以被视作被 pi 指向的对象。则上面的语句实际上将 pi 指向的对象中的内容改写为了 0，但该对象在内存中的地址，也就是 pi 中存储的地址，是没有发生变化的。

• 指针在某些情况下可以用做条件判断。当指针为空指针的时候，条件为假，反之为真。
• 指针之间可以进行比较（通过比较运算符 == 等等）。两者相等的条件是两个指针指向的地址相同（或者是指向相同对象的二类指针，或者是都指向空指针）

还有一类特殊类型的指针 *vold。这种类型的指针与普通指针不同的地方在于它可以指向任意类型的对象（有点 O型血的那么个意思）。以下是几种该指针的应用：

• 与其他指针比较
• 传递给函数或者作为函数的返回值
• 赋值给另外一个 void 类型的指针

这种指针的局限性在于，不能通过 void 指针来对其指向的内容进行操作，因为对指向对象操作的前提是必须知晓该对象的类型。

在定义（* 或者 & 作为 type modifier 使用）的时候，type modifier 只对最近的一个变量起作用，因此定义多个变量需要在每个变量前都加上 type modifier:

int* p; //bad practice, misleading
int *p0; //good practice to define a pointer with int type
int* p1, p2; //p1 is a pointer , p2 is an int variable
int *p3, *p4; //good way to define multiple pointers in 1 statement.

指针本身是对象，也会拥有自身的地址。因此定义指向指针的指针也是可以的：

int i = 1024;
int *pi = &i;
int **ppi = π //&pi is the address of the pointer, not the address which pointer points

当然，如果需要通过 ppi 来访问 i 的内容，我们需要解引用两次：

std::cout << **ppi << std::endl;

引用不是对象，因此不存在指向引用的指针。但反过来则可以：

int i = 0;
int *p;
int *&r = p; //reference to pointer
r = &i; //r is an altertive name to p, so assign the address of i to r makes p points to i.
*r = 0; // dereference r means dereference p, which yields i. then changes i to 0

复合类型的混用向来比较让人困惑。书上讲了一个阅读的规则，那就是从右往左读定义。也就是说，离变量名右侧最近的type modifer，决定了该定义的复合类型（比如下面在 *&r 中的 & ）。

比如这个例子：

int *&r =  i;

来分析一下这个步骤：

1. 首先找到 r，确定变量名
2. 往右看看到 &，确定定义的是名称为 r 的引用
3. 继续往左看则是声明的引用 refer 的指针类型：int*，这里实际上写成 int* &r = i 更好理解。

因此这就是一个与整型指针绑定的引用的声明过程。

const 修饰符（Qualifier）是用来定义我们不希望被改变的变量。因为这个变量不能再建立之后改变，所以我们只能在初始化的时候给其赋值，也就是说：const 修饰的变量必须被初始化。

const int i = 10; //ok
const int j; //error, const variable must be initialized.
i = 20; //error, attempt to write to const object

我们也可以用表达式来作为 const 初始化的值，比如：

const int k = getsize();//initialized at runtime

由于编译的时候，const 变量会被编译器自动替换为其值，编译器会在编译期寻找 const 变量对应的初始值。因此 const 修饰的变量是必须是编译器可见，即拥有完整定义的变量。由于 C++ 支持分离编译，如果该变量在多个文件中均存在，那么需要在每个文件中都有定义。但问题在于，C++ 遵循唯一定义规则，因此需要通过两种方法来解决：

1. 针对每个文件单独创建一个 const 变量。
2. 通过 extern 关键字共享唯一的 const 变量。

第二种情况下，为了使用外部的 const 变量，我们需要定义以及声明两个步骤：

• 在指定的源文件（.cc / .cpp）中定义 const 变量。这里的 const 变量可以接受对象，甚至函数：

/*file.cc, defines and initializes a const, that is accessible to other files*/
extern const int bufSize = fcn(); //initializer can be a function

• 之后通过头文件对该变量进行声明，来达到共享的目的：

/*file.h, declar the bufSize. Include the header to share variable bufSize*/
extern const int bufSize;

一个简单的多文件共享全局变量的例子如下：

• extern_const_test_def.cpp 文件用于定义需要共享的全局变量
• extern_const_test_def.h 用于声明需要共享的全局变量
• extern_const_test.cpp 用于使用共享的全局变量

/*extern_const_test_def.cpp*/
extern const int bufSize = 512;

/*extern_const_test_def.h*/
extern const int bufSize;

/*extern_const_test.cpp*/
#include <iostream>
#include "extern_const_test_def.h"
int main(int argc, char const *argv[])
{
	std::cout << "The size of global buffer is: "<< bufSize << std::endl;
	return 0;
}

编译以及链接的过程：

#分别对 cpp 文件进行编译
#如果没有 main 函数，g++ 需要使用 -c 来编译 c++源文件
g++ -c extern_const_test.cpp
g++ -c extern_const_test_def.cpp
#对得到的 .o文件进行链接
g++ -o a.out extern_const_test.o extern_const_test_def.o
#访问
./a.out

对 const 的引用指“reference that refers to a const type”，基于const 修饰类型的引用。这类引用确保了不能通过该引用修改绑定对象的内容。

const int ci = 1024;
const int &r1 = ci; // defines a refernece refers to a const variable
int &r2 = ci; // error. a plain reference can't refers to a const object

绝大多数情况下，引用的类型必须与被引用的对象一致；但有一种例外：如果被绑定的对象的类型，能够通过类型转换变得与引用的类型一致，那么这样的对象也是可以用于引用的初始化的：

int i = 42; //variable i
const int &r1 = i; // r1 is the reference refers to a const varible, initialized by a non-const int object
const int &r2 = 42; // ok. initializor can be convert to const int
const int &r3 = r1*2; //ok. initializor can be convert to const int
int &r4 = r1 * 2; //error, const int initializor can't be convert to non-const int.

这种情况下，引用的绑定实际上分为两步：

1. 创建一个临时的 const 对象，使用目标对象对其进行初始化；
2. 将引用与该临时的对象绑定

类型转换将发生在第一步，也就是说临时对象的类型会与引用一致。那么实际上，我们定义的引用绑定的是一个不可更改的，经过类型转换的临时对象。该对象显然不能被 refer to non-const 的引用绑定。

只要被绑定的对象可以转化为 const 类型，那么无论被绑定的对象是不是 const, 都不会影响 reference to const 的初始化（注：literal 也可以通过上述步骤转化为临时对象！）。下面是一个实例：

int i  = 42;
int &r1 = i; //ok, non-const bind to non-const
const int &r2 = i; // ok const bind to non-const
//*now, r1 and r2 refer to the same int variable i*//
r1 = 0; //ok, we can modify i through non-const reference r1
r2 = 0; //error, we can't modify i through const-const r2 
/*and finally i is changed to 0*/

Ref:const reference can be assigned an int?

指针是对象。所以 const 和指针连用就分成了以下的两种情况：

• pointer to const：与 reference to const 类似，指不能通过该指针去修改被指向的内容（指针绑定的内容）
• const pointer：指该指针指向的地址无法被改变（指针本身）

这两种组合的初始化也比较容易混淆：

int i = 10;
const int *p = &i; //define a pointer to const
int *const q = &i; //define a const pointer that point to i

这里我们的从右向左看的方法依然适用（C语言中还有 int const *p, 这个写法跟 const int *p 等同）。

还有一个用法：

const int *const ptr = &i; // ptr is a const pointer,its value can't be changed, and the value pointed by it cannot be changed through itsself(the pointer).

同样先前说到的初始化的时候类型要匹配规则同样适用于这里。比如：

const double x = 3.1415;
double *xptr = &x;// error, type not match.

根据 pointer 与 const 的两种组合方式，我们可以定义两种等级：

• 自身为 const 的等级为 top level，比如 const pointer
• 无法通过自身修改对应内容的等级为 low level, 比如 pointer to const

示例代码如下：

int i = 10;
// const pointer, its-self cannot be changed -> this const produces a forbidden operation of manipulating the object -> top_level
int *const p = &i; 
// pointer to const, the pointer its-self can be changed, but the value of i can't be changed by using the pointer(expression)-> this const produces a forbidden operation of manipulating the i(what the expression did once)-> low_level
const int *q = &i;

还有一个例子：

const int *const ptr = &i; //right-most const is top_level, left_most is not

右边的 const 定义了 指针，因此是 top level, 左边的 const 定义了该指针指向的是一个不能改变的 int 值，因此属于 Low level。

之所以提出这两个 level, 是因为绝大多数的，带 const 初始化/赋值的合法性，都可以使用该概念来判断：

首先，拷贝 const 对象的时候，top-level 可以无视，因为拷贝并不影响 const 对象的内容：

int i = 0;
const int ci = 42;
i = ci; //top-level ci is ignored.

其次，low-level 的 const 在任何时候都不能忽略。如果想要成功拷贝，那么等号两边都必须是 Low-level 的 const,或者有可以转换为 const 的对象；因此，non-const 可以转化为 low-level 的 const，但反过来不行（也就是不能拷贝 const 到 non - const）:

/*接上面*/
int &r = ci; //error, ci is on low-level, r must at the same level.

下面是特殊情况，指向 const 且自身是 const pointer：

/*接上面*/
const int *p2 = &ci; 
const int *const p3 = p2;

该指针左边的 const 为 low-level, 右边的 const 为 top-level。因此：

• p3 可以初始化、赋值 p2, 拷贝的时候 top-level 自动忽略了。
• p2 可以初始化 p3。两边的 low-level 匹配。

这一节有一个概念，常量表达式（Const Expression）。 常量表达式是指在自身值无法改变，且初始化值在编译阶段就可以确定的表达式，比如 literal、被常量初始化的 const 对象等等。

因此，所有非常量的表达式，或者需要在 Run Time 下才能确定初始值的表达式（比如函数），都不是常量表达式。比如：

int a = 10; // a is not const object
const int b = getsize(); // getsize() fincution is an uncertain initializor during the compling time. 
const int c = 100; // const expression

因为在大型系统中，判断一个表达式是不是 const 比较麻烦–你觉得你定义的常量是被“常量表达式”初始化的，但往往并不是。为了确保得到真正的常量表达式，C++11 新标准中提出了一个关键字 constexpr 。constexpr 会要求编译器验证表达式是不是常量表达式。被 constexpr 修饰的变量定义表达式，必须满足常量表达式的两个特性，即：

• 声明的变量必须是明确的 const （Top const）
• 该变量必须被一个常量表达式初始化。

因为常量表达式的初始值需要在编译期确定，因此 constexpr 的对象的初始化会有一些局限性：

1. constexpr 只接受 Literal Types (比如算术类型和复合类型）
2. constexpr 不支持校验自定义对象类型（比如类）
3. constexpr 指针不能指向函数内定义的变量（地址不确定）

在定义 constexpr 指针的时候，constexpr 特指指针的类型（top-level），而不是指针指向对象的类型：

const int *p = nullptr; // p is a pointer to const int
constexpr int *q = nullptr; // q is a const pointer to int

const int *const p 这样的形式换成 constexpr 来定义可以写成这样：

constexpr const int *p = &i;

Ref:Constexpr - Generalized Constant Expressions in C++11

类型随着程序的复杂性变大会出现两个比较显著的问题：

• 类型名会变得越来越长，变得难懂并且容易输错
• 类型的形式太复杂导致需要看完类型的内容才能明白

解决第一类问题可以用到 Type Alias。 总的来说，Type Alias 就是为某种类型找一个同义词，通过简化复杂的类型使其更为易用。

有两种方法可以定义 Type Alias:

1. typedef,格式为: typedef + 被定义的类型 + 同义类型

typedef double wages; // wages is a synonym for double''
typedef wages base; //base is synonym for double
typedef wages *p; // p is synonym for double*

1. C++11的新标准：using

   using SI = Sales_items;// Si is a synonym for Sales_items
   SI item; // same sa Sales_item type

Type Alias 也可以与复合类型，const 一起使用，但需要注意的是，const 修饰的是 Type Alias。因此在与指针连用的时候要注意，const 修饰的永远是 Type Alias 中的变量类型，比如：

typedef char *pstring; 
const pstring cstr = 0; 
// const 修饰的是经过type alias化的指针
// const pstring -> const char *，cstr 是指向 char 的常量指针
// 而不是指向常量 char 的指针（char const*）

在很多时候，我们想自己决定表达式的类型是非常困难的。C++11引入了一种新的类型说明符 auto，让编译器自动决定表达式的类型。因为编译器需要根据变量的初始值来判断类型，所以用 auto 声明的变量必须初始化。
和别的说明符一样，auto 定义多个变量的时候，所有变量必须是同一类型。

auto 与复合类型还有 const 连用的时候，有几个点需要注意：

首先，使用引用对某类型进行初始化的时候，auto 会将该类型推断为引用 refer to 的类型：

int = 0, &r = i;
auto a = r; // a is an int

其次，在有 const 参与的类型初始化中，auto 会自动忽略 top-level const：

const int ci = i, &cr = ci;
auto *p = &ci; // p points to a const variable, low-level
auto b = i;// b is an int
auto c = cr; // c is an int
auto d = &i; // d is an int*

如果需要保留 top-level const, 需要显式的添加上 const:

const int i = 0;
const auto a = i;

除此之外，low-level const 不会被 auto 忽略，因此 auto 不会将 low-level const 的引用类型识别为其绑定的类型：

const int ci = i;
auto &g = ci; // g is an reference refer to const int ci
auto &h = 42; // error, plain reference can be bound to a literal
const auto &j = 42;// reference to const can be bound to literal

decltype 与 auto 类似，也用于自动判断变量的类型。与 auto 不同的是，decltype 是通过表达式在编译期推断出变量的类型。因为 decltype 并不要求执行表达式，因此不需要初始化。那么有时候我们想让编译器自己推断一个表达式的类型，但是又不想用这个表达式做初始化，这时候我们就要用 decltype 了。decltype 的用法如下：

decltype(f()) sum = x; //sun has whatever x returns

跟 auto 不一样，变量是什么类型，decltype 就返回什么类型，包括 top_level const 和 引用类型：

const int ci = 0; &cj = ci;
decltype(ci)  x = 0; //x is const int
decltype(cj) y = x //y is reference to const int x
decltype(cj) z; //error, exception; if z requires initialize, then the initialization is a must.

注意 decltype 与引用连用的时候需要初始化（因为引用需要）。与 auto 不同的是，decltype 会返回其表达式的类型，因此这里返回的是引用，所以必须初始化。

decltype 的返回类型是根据表达式的表现形式来判断的。我们设定 e 的类型为 T；

1. 如果表达式是函数，那么返回的就是函数返回值的类型
2. 如果 decltype(e) 中，e是一个实体（Entity）的名字（id 表达式），那么 decltype 返回的是名字为 e 的实体（Entity）的类型。
3. 如果 e 是表达式：
   1. 如果表达式 e 是个左值，decltype(e) 返回的就是 T&（T 的引用），注意：如果有括号，括号里的表达式将被视为左值。
   2. 否则，返回的是 e 的返回结果的类型。

Refs：

• C++11 standard P153 section.4
  
• decltype specifier
• What are rvalues, lvalues, xvalues, glvalues, and prvalues?

一些例子：

int i = 10;
int &r = i;
int *p = &i;
decltype(i) x1 = 0; //decltype ( entity )形式，返回 i 的类型int
decltype(r) x2 = x1;//decltype ( entity )形式，返回绑定int变量的引用（r绑定的是i)
decltype(r+0) x3;//decltype ( expression )形式，r+0的结果类型是int，但r+0不能作为lvalue，所以返回int
decltype(*p) x4 = i;//decltype ( expression )形式，*p是lvalue，那么返回的是T& .*p表示的是int变量i的值，那么返回的类型就是对int变量的引用。
decltype((i)) x5 = i;// if the name of an object is parenthesized, it is treated as an ordinary lvalue expression.(i)是lvalue,那么返回T&,也就是int的引用。
decltype('a') x6;//e是prvalue(pure value),返回e自身的类型。

一些注意事项：

• class 定义的末尾要加一个 semicolon
• object 的定义最好与 class 的定义分开

• 因为 class 的复用性，因此 class 的定义通常应该放到 header 中。

Preprocessor 继承至 C，指一系列在编译器改变源代码之前运行的程序，比如 #include。Preprocessor 有一个用途是解决多重包含。

在我们的 C++ 程序中，资源往往来自不同的头文件，某一些头文件之间可能会有互相的依赖。比如我们自定义的头文件 Sales_item.h，为了输出字符串，必须包含 string 头文件。如果在接下来的某个源文件中需要同时使用 Sale_item 和 string 中定义的资源，那么该文件就会多重包含 string 头文件。

多重包含会带来什么问题？

C++ 中，某对象的声明可以有很多次，定义只能有一次。多重包含往往会导致某个对象的重复定义，这是不被允许的。

为了解决这个问题，C++ 提供了 Header guards。Header guards 使用 preprocessor 提供的变量来确保当前 header 只被包含一次：

#ifndef SALES_DATA_H //检测之前该 header 有没有被定义（包含）
#define SALES_DATA_H //如果 header 是被第一次包含，那么证明该 header 未被定义过，执行下列语句
#include <string>
struct Sales_data {
std::string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};
#endif

其中 #define 用于存储当前变量的状态，有两种情况：定义或者未定义。而 #ifndef / #ifdef - #endif 字符段用于判断当前的变量是否被定义。#ifdef 表示如果当前变量已经定义进行下一步, #ifndef 表示当前变量没有被定义则进行下一步。因此上边代码实际上会这么运行：

• 如果当前程序第一次包含 Sales_data.h 头文件，#ifndef 测试成功，对 SALES_DATA_H 进行定义，并拷贝 Sales_data.h 到目标程序。
• 如果已经包含了 Sale_data.h 头文件，那么 #ifndef 测试会失败，那么代码段之间的内容会直接被忽略掉。

需要注意的是，Preprocessor 中的所有变量，必须是唯一的，并且必须全大写（避免与其他名字发生冲突）。