创建时间： 2020-6-19

* [《C++标准程序库》]()
* [《Effective C++》]()
*   - 《Linux 多线程服务器编程》

Processes and Threads (Windows)
https://docs.microsoft.com/en-us/windows/win32/procthread/processes-and-threads?redirectedfrom=MSDN

Synchronization (Windows)
https://docs.microsoft.com/en-us/windows/win32/sync/synchronization?redirectedfrom=MSDN


    - 《UNIX 环境高级编程》
    - 《UNIX 网络编程》
    - 《现代操作系统》
    - 《c++标准库》
    - 《c++ concurrency in action》
* 《C++ Concurrency in Action》
* [Synchronization(windows)](https://docs.microsoft.com/en-us/windows/win32/sync/synchronization?redirectedfrom=MSDN)
* [Processes and Threads(windows)](https://docs.microsoft.com/en-us/windows/win32/procthread/processes-and-threads?redirectedfrom=MSDN)
* [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html)

c++11 c++的蜕变 GNU编译器

本书的结构 第一部分和第二部分中介绍了C++语言和标准库的内容。这两部分包含的内容足够你编写出有意义的程序，而不是只能写一些玩具程序。大部分程序员基本上都需要掌握本书这两部分所包含的所有内容。

本书源码下载地址

第一章 开始

主要内容: 大部分基础内容, 类型 变量 表达式和函数. 学习完你将具备编写 编译 及运行简单程序的能力

1.1 编写一个简单的C++程序

int main(){

    return 0;

}

第一部分 C++基础

第二章 变量和基本类型

2.1 基本内置类型

• 算术类型 arithmetic type 字符、整型、布尔值、浮点型
• 空类型 void 函数不返回值时返回空类型

2.1.1 算术类型

分为整型(integral type, 包括字符和布尔类型)和浮点型

算术类型的尺寸（所占比特数）在不同机器上有差别

带符号类型和无符号类型

• signed 正数、负数、0
• unsigned 大于0的数

int 、 short 、 long 和 long long 都是带符号，通过添加 unsigned 就可以得到无符号类型。 unsighed int unsigned short 字符类型与其他不同，有三种 char signed char unsigned char ，但最终的类型还是只有：带符号的和无符号的两种。 char 和 signed char 并不相等， char 具体表现为哪种类型由编译器的实现决定。

无符号类型中的所有比特都用来存储值，例如，8比特的 unsigned char 表示0-255区间内的值

C++语言规定一个int至少和一个short一样大，一个long至少和一个int一样大，一个long long至少和一个long一样大。long long是C++11中定义的

2.1.2 类型转换

• 非布尔的算数值赋值给布尔： 初始值为0时结果为false，否则结果为true
• 布尔值赋值给非布尔值：初始值为false结果为0, 初始值为true结果为1
• 浮点值赋值给整数：取小数点前面整数
• 整数赋值给浮点数：小数部分记为0, 若整数所占空间超过浮点类型的容量，精度可能有损失
• 赋值给无符号类型一个超出它范围的值时候：结果是对无符号类型数值总数取模后的余数。
• 赋值给有符号类型一个超出它表示范围的值时候：结果为undefined。此时程序可能继续工作，可能崩溃，也可能生成垃圾数据。

建议：避免未知和依赖于实现环境的行为

含有无符号类型的表达式会将结果转化为无符号类型。

提示：不要混用带符号类型和无符号类型

2.1.3 字面值常量

整型和浮点字面值

20 // 十进制
024　// 八进制　
0x14　// 十六进制

3.14159
3.14159E0
0.
0e0
.001

字符和字符串字面值

'a'    // 字符字面值
"hello wolrd" // 字符串字面值

String literal

字符串字面值实际上是由常量字符构成的数组(array), 编译器会在每个字符串的结尾处加上一个空字符 '\0' 。因此。字符串字面值的实际长度要比它的内容多1。

'A'  // 表示 A
"A"  // 表示 A\0

如果两个字符串字面值位置紧邻且仅由空格、缩进和换行符分隔，则它们实际上是一个整体

std::cout<< "hello" "world"

            "in C++"

转义序列 有两类字符程序员不能直接使用： 1 不可打印字符，如退格，因为它们没有可视的图符。 2 特殊含义字符（单引号，双引号，问号，反斜线），需要用转义序列

cout << '\n';               // 转到新一行
cout << '\tHi!\n'           // 输出一个制表符，输出“Hi!”,转到新一行

泛化的转义序列，形式是\x后紧跟着1个或多个十六进制的数字，或者紧跟着1个或多个八进制的数字

cout << "Hi \x4dO\115!\n" // 输出 Hi MOM！，转到新一行

指定字面值的类型

布尔字面值和指针字面值 true和false是布尔类型的字面值

bool test=false

nullptr 是指针的字面值

2.2 变量

2.2.1 变量定义

类型说明符(type speccifier)，随后紧跟一个或者多个变量名组成的列表，变量名以逗号分隔，最后以分号结束。

int sum = 0 , value , 
    units_sold=0;

Sales_item item;
std::string book("I am a Book");

<<C++Primer>> 书中的变量和对象通常指的都是同一个东西->变量

初始值 当变量在创建时获得了一个特定的值，我们说这个变量被初始化了（initailized） 在C++中初始化是一个复杂的问题，在C++中赋值和初始化是两个完全不同的操作，然而在很多编程语言中二者的区别几乎可以忽略不计。

初始化不是赋值，初始化的含义是创建变量时赋予其一个初始值，而赋值的含义是把变量的当前值擦除，用一个新值来替换。

列表初始化 C++语言定义了初始化的好几种不同的形式。

// 定义一个名为unit_sold的int变量并初始化为0
int unit_sold = 0;
int unit_sold = {0};
int unit_sold{0};
int unit_sold(0);

使用花括号来初始化变量是c++11标准的一部分，被称为列表初始化。当用于内置类型的变量时，这种初始化形式有个重要的特点：使用列表初始化如果存在丢失信息的风险时，会在编译时报错。

long double id=3.1415926536;
int a{id}, b={id} // 编译报错，转换未执行，long double 转int会丢失精度。
int c(id), d=id  // 不报错，自动转换，会丢失精度

默认初始化 如果变量没有指定初始值，则被默认初始化(default initialized)

内置类型的变量的默认初始化，它的值由定义的位置决定

• 函数体外的变量初始化为0
• 函数体内部的内置类型变量将 不被初始化(uninitialized), 即未定义的，此时试图拷贝或者以其他形式访问此类值将会发生错误

类的初始化方式由自己决定，是否初始化和如何初始化

绝大多数类都支持无须显示初始化而定义对象，这样的类提供了一个合适的默认值。

定义于函数体内的内置类型的对象如果没有初始化，则其值未定义。类的对象如果没有显式初始化，则其值由类确定。

2.2.2 变量的声明和定义的关系

C++支持分离式编译(separate compilation), 该机制允许将程序分割为若干哥文件，每个文件可被独立编译。

为了支持分离式编译，C++语言将声明和定义区分开来

• 声明（declaration）使得名字为程序所知，一个文件如果想使用别处定义的名字则必须包含对那个名字的声明
• 而定义（definition）负责创建与名字关联的实体

变量声明规定变量的类型和名字 定义规定变量的类型和名字, 还申请存储空间，也可能回味变量赋一个初始值

使用extern声明一个变量

extern int i; // 声明而非定义i
int i; // 声明并定义i

extern语句如果包含初始化的值就不是声明了，而是定义

extern int i=1; // 定义
extern double pi=3.1415926; // 定义

变量只能被定义一次，但是可以被多次声明

C++是静态类型（static typed）语言，会在编译阶段检查类型。其中检查类型的过程称为类型检查(type checking)

2.2.3 标识符

C++的标识符（identifier）由字母数字和下划线组成，其中必须以字母或下划线开头。长度没有限制，但对字母大小写敏感。

变量命名规范

• 标识符要能体现实际含义
• 变量名一般用小写字母
• 用户定义的类名一般用大写字母开头
• 如果标识符由多个单词构成，则单词间应该有区分，驼峰或pascal

2.2.4 名字的作用域

C++中的作用域大多数以花括号分隔。

#include <iostream>
int main(){
    int sum=0;
    for(int val=1;val<=10;++val){
        sum+=val;
        std::out << "Sum of 1 to 10 inclusive is"
                 << sum << std::endl;
        return 0;
    }
}
/* 
    这段程序定义了3个名字，main,sum 和val，
    同时使用了命名空间名字std，
    该空间提供了2个名字cout和cin供程序使用
*/

名字 main 定义于所有花括号之外，它和其他大多数定义在函数体之外的名字一样拥有全局作用域，在声明后，全局作用域变量在整个程序范围内都可以使用。

名字 sum 定义于 main 函数所限定的作用域之内，从声明到 main 函数结束都可以使用，拥有块级作用域。

名字 val 的块级作用域在for循环之内

在变量第一次使用的地方之前附近定义它是一种比较好的代码习惯

嵌套的作用域 作用域彼此包含，根据包含关系分为

• 内层作用域
• 外层作用域

外层作用域中的变量，在其内层作用域中都可以访问，同时允许内层作用域重新定义外层作用域已有的名字

#include <iostream>
// 该程序仅用于说明，函数内部不宜定义与全局变量同名的新变量
int reused = 42;
int main(){
    int unique = 0; // unique拥有块级作用域

    /* 使用全局变量reused，输出：42 0 */
    std::cout << reused << " " << unique << std::endl;

    int reused = 0; //新建局部变量reused,覆盖了全局变量
    
    /* 使用局部变量reused, 输出：0 0 */
    std::cout << reused << " " << unique << std::endl;

    /* 显示地访问全局变量，输出：42 0 */
    std::cout << ::reused << " " << unique << std::endl;

    return 0;
}

如果函数有可能用到某全局变量，则不宜再定义一个同名的局部变量

Scope 作用域:

• block scope 块级作用域
• Function parameter scope 函数参数作用域
• Namespace scope namespace作用域
• Class scope 类作用域
• Enumeration scope 枚举作用域
• Template parameter scope 模板参数作用域
• Point of declaration 声明处

2.3 复合类型

复合类型指基于其他类型定义的类型，C++语言有好几种复合类型，本章介绍：引用和指针

一条声明语句由一个基本数据类型 base type和一个紧随其后的一个声明符 declarator列表组成。

2.3.1 引用

C++11新增的右值引用在13.6.1介绍，通常说的引用指的是本章的左值引用。

引用 reference 为变量起了另一个名字，引用类型引用 refer to另外一种类型。

int ival = 1024;
int &refVal = ival;     // refVal指向ival（是ival的另一个名字）
int &refVal2;       // 报错，引用必须被初始化

在初始化变量时，初始值会被拷贝到新建的变量中。而在定义引用时，程序把引用和它的初始值绑定 bind在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用会和其绑定的变量一直绑定在一起。因为无法重新进行绑定，所以引用必须初始化。

引用即别名 定义了一个引用后，对其进行的所有操作都是在与之绑定的对象上进行的。

refVal = 2;      // 把2赋给refVal引用的变量，即ival
int ii = refVal; // 把refVal引用的变量的值赋给ii，等价于 int ii=ival

/* refVal3绑定到refVal绑定的变量，即绑定到ival上 */
int &refVal3=refVal; 

/* i被初始化为refVal绑定的变量的值，即ival */
int i=refVal; 

引用本身不是一个对象，所以没有办法定义引用的引用（因为最终会绑定到引用所绑定的变量上）

引用的定义

/* 允许在一条语句中定义多个引用，其中每个引用标识符都必须以&开头 */

int i=1024, i2=2048;    // i和i2都是int
int &r=i, r2=i2;       // r是一个引用，与i绑定在一起，r2是int
int i3=1024, &ri=i3;    // i3是一个int，ri是一个引用，与i3绑定
int &r3=i3, &r4=i2;    // r3和r4都是引用

引用只能绑定在对象上，而不能直接与某个字面值或者某个表达式的计算结果绑定在一起。基本上所有引用类型都要与绑定的变量的类型严格匹配。

int &refVal4 = 10; // 错误，引用类型的初始值必须是一个变量
double dval = 3.14; 
int &refVal5=dval;  // 错误，这个引用类型的初始值必须是int类型

2.3.2 指针

指针是 指向refer to 另外一种类型的符合类型。与引用类型类似，指针也实现了对其他变量的间接访问。不同的是：

• 指针是一个变量，允许对指针赋值和拷贝，而且在指针的生命周期中可以先后指向不同的变量
• 指针无须在定义时赋值，和其他类型一样，没有被初始化的指针也将拥有一个不确定的值

定义指针类型的方法将声明符写成 *d 的形式，其中d是变量名。

int *ip, *ip2;      // ip1和ip2都是指向int类型对象的指针
double dp, *dp2;    // dp2是指向double型对象的指针，dp是double型对象

获取变量的地址 指针存放某个变量的地址，使用取地址符 & 取变量的内存地址

int val = 0;
int &refVal = val; // 声明并初始化引用
int *pVal = &val;  // 声明并初始化指针
int *pVal2 = &refVal;   // 当取某个引用的地址时候，实际上取到的refVal引用的变量，即&refVal 等价于 &val

和引用一样，大部分情况下指针的类型和它指向的变量类型应该保持一致。

指针值 指针的值有四种情况：

• 指向一个变量
• 指向紧邻变量所占空间的下一个位置
• 空指针，指针没有指向任何变量
• 无效指针，除上面3种的任何情况

试图拷贝或以其他方式访问无效指针的值都将引发错误。编译器不会检查此类错误，和使用为初始化的变量一样都不会检查。访问无效指针的结果无法预计，因此程序员必须清楚任意给定的指针是否有效。

虽然第2种和第3种形式的指针是有效的，但是这些指针没有指向任何具体对象，所以试图访问此类指针的行为不被允许。如果这样做了，后果也无法预计。

利用指针访问变量

如果指针指向了一个变量，则允许使用解引用符 * 来访问变量。

int ival=42;
int *p=&ival;
cout << *p;         // 42 
cout << p;          // p的内存地址

对指针解引用会的出所指的对象，因此如果给解引用的结果赋值，实际上也就是给指针所指的变量赋值。

*p = 0;      // 由符号*得到指针p所指的对象，即可经由p为变量ival赋值
cout << *p;  // 输出0
cout << ival;  // 输出0

解引用操作仅适用于那些确实指向了某个对象的有效指针

某些符号有多重含义，像 * 和 & 这样的符号，既能用作表达式中的运算符，也能作为声明的一部分出现，符号的上下文决定了符号的定义：

int i = 42;
int &r = i;     // &紧随类型名出现，因此是声明的一部分,r是一个引用
int *p;         // *紧随类型名出现，因此是声明的一部分,p是一个指针
p = &i;         // &在表达式中出现，是一个取地址符，指针p指向变量i的地址
*p = i;         // *出现在表达式中，是一个解引用符，指针p的地址赋值为i的值
int &r2 = *p;   // &是声明的一部分，*是一个解引用符，用rs绑定到*p解引用的结果i上，等价于 int &r2=i;
bool rs = bool(*p == i); // true
cout << r2 << " " << rs;

空指针

空指针 null pointer 不指向任何变量，在试图使用一个指针之前可以首先检查它是否为空。一下列出几个生成空指针的方法：

int *p1 = nullptr;  
int *p2 = 0;

/* 需要include cstdlib */
int *p3 = NULL;

C++11中使用 nullptr 来初始化空指针，它会转换成对应类型的空指针。（int则为0）

直接将指针的值初始化为0来生成空指针。

赋值为预处理变量 NULL 来生产空指针，这个变量定义在头文件 cstdlib 中，它的值就是0。

把int变量直接赋值给指针是错误的，（这样也不会将指针初始化为空指针），即使这个变量的值刚好等于0也不行。

int zero = 0;
int *pi = zero;  // 编译错误：不能将int变量直接赋值给指针

初始化所有指针，使用未初始化的指针是引发运行时错误的一大原因。和其他变量一样，访问未经初始化的指针所引发的后果也是无法预计的。这一行为会导致程序崩溃，且很难定位到出错的位置。大多数编译器会把未初始化的指针所占空间看作一个内存地址，访问该指针相当于访问一个本不存在的位置上本不存在的变量。更糟糕的是，如果指针所占内存空间中恰好有内容，而这些内容又被当作了某个地址，我们就很难分清楚它是合法还是非法的了。

因此建议初始化所有指针，尽量等定义了变量后在定义指向它的指针，或者把它初始化为努力nullptr或者0，这样程序就可以正确的检测它指向的变量或者知道它没有指向任何变量。

赋值和指针 指针和引用都可以提供对其他变量的间接访问，不同点是

• 引用本身不是一个变量，一旦定义了引用，就无法令其再绑定到另外的对象，之后的每次使用这个引用都是访问它最初绑定的那个变量
• 指针和它存放的地址就没有这种限制了。和其他变量一样，给指针赋值就是令它存放一个新的地址，从而指向一个新的对象

int i = 42;
int *pi = 0;    // 指针pi被初始化为空指针
int *pi2 = &i;  // 指针pi2被初始化，存放变量i的地址
int *pi3;       // 指针pi3未被初始化，如果pi3定义与块内则pi3的值是无法确定的

pi3 = pi2;         // pi3和pi2指向通一个变量i了
pi2 = 0;           // pi2现在是一个空指针了，pi3还是指向i

有时候想搞清楚一条赋值语句到底是改变了指针的值还是改变了指针所指的对象不太容易，最好的方法是记住赋值永远改变的是等号左侧的变量。

int ival = 1;   
int *pi = nullptr;   // 指针pi初始化为空指针
pi = &ival;         // 指针pi指向ival， pi的值改变为ival的内存地址
*pi = 0;            // 解引用取到指针pi所指的变量ival,ival的值改变为0;

// *pi == ival;   true  
// pi == &ival;   true

其他指针操作 任何非0(空)指针对应的条件值都是true

int ival = 0;
int *pi = nullptr;
int *pi2 = &ival;

if(pi)      // false
if(pi2)     // true

两个同类型指针可以用相等操作符来比较 == != , 结果也是布尔值。如果两个指针内存地址相同返回 true , 否则 false 。

指针的比较和判断都需要使用合法指针，使用非法指针的结果无法预计。

void* 指针 void* 是一种特殊的指针类型，可用于存放任意变量的地址。一个 void* 指针存放着一个地址，这与其他类型指针一致，不同的是，所指地址中变量的类型是未知的。

double obj = 3.14, *pd = &obj;
void *pd2 = &obj   // 正确，void*能存放任意类型的变量
pd2 = pd;          // 也可以存放任意类型的指针

void* 指针能做的事情比较有限，不能直接去指针所指操作变量的, 因为无法确定指向变量的类型，也就无法确定能做什么操作。（仅可用于条件、比较、作为函数的输入输出和赋值给另一个void*指针）

以 void* 指针来看内存空间也就仅仅是内存空间，没办法访问内存空间中所存的对象。

2.3.3 理解复合类型的声明

一条定义语句可以定义出不同类型的变量（数据类型相同，变量类型不同）

int i = 1024, *p = &i, &r = i;
/* i是一个int类型的数字，p是一个int型指针，r是一个int型引用 */

基本数据类型和类型修饰符都是声明符的一部分

定义多个变量 经常有一种误解认为类型修饰符 * 和 & 会作用与本次定义的全部变量，其实并不是，类型修饰符只作用于其后紧跟的一个变量。

int* p1;          // 合法但是容易产生误导
int *p1, p2;     // pi是int型指针，p2是一个int型变量

本书采用类型修饰符和变量紧跟，而不是和类型声明紧跟。

int *i = nullptr;

指向指针的指针 一般来说，声明符中的修饰符个数没有限制。当有多个修饰符连写在一起时，按照其逻辑关系详加解释即可。

以指针为例，指针是内存中的对象，像其他对象一样也有自己的地址，因此允许把指针的地址再存放到另一个指针中。

通过声明中 * 的个数可以区分指针的级别，也就是说， ** 表示指向指针的指针， *** 表示指向指针的指针的指针。（禁止套娃…）

int ival = 1024;
int *pi = &ival;        // pi指向一个int型的整数
int **pi2 = π        // pi2指向一个int型的指针

/* 注意区分 */
int *pi3 = pi;          // 指针pi3和指针pi指向同一个变量ival

解引用int型指针会得到一个int型的数，同样解引用指向指针的指针会得到一个指针。此时为了访问最原始的那个对象，需要对指针的指针做两次引用。

cout << ival        // 1024
     << *pi         // 1024
     << **pi2       // 1024     
     << *pi2        // 指针pi的内存地址
     << pi          // ival的内存地址

指向指针的引用 引用不是一个变量，因此定义不了指向引用的指针(指针最终会指向引用绑定的变量) 而指针是一个变量，所以存在对指针的引用。

int i= 42;
int *p;         // p是一个int型指针
int *&r = p;     // r是一个对指针p的引用

r = &i;         // r引用了一个指针，因此给r赋值就是令p指向i
*r = 0;         // 对*r 等价于 *p,此处将i赋值为0

理解 int *&r = p; , 离变量名最近的 & 对r由最直接的影响，因此r是一个引用，符号 * 说明r引用的是一个指针，最后声明的基本数据类型部分指出r引用的一个int指针。

对于一条复杂的声明语句，从右往左阅读有助于弄清楚它的真实含义

2.4 const 限定符

有时我们希望定义这样一种变量，它的值不能被改变。

const int bufSize = 512;
bufSize = 1024;         // 错误，试图向const对象写值

用const把bufSize定义成了一个常量，任何试图为bufSize赋值的行为都将引发错误。初始值可以是任意的复杂表达式：

const int i = get_size();   
const int j = 42;
const int k =;

初始化和const const类型可以进行除开改变自身值之外的所有操作，比如赋值给其他变量，初始化其他变量，参与算术运算，转换成布尔值等。

默认状态下，const对象只在文件内有效 编译器在编译const变量时，会把用到该变量的地方都替换成对应的值。

const int bufSize = 512;        

/* 编译时会把用到bufSize的地方都替换为512 */

const默认只在定义的文件内有效，如果有多个文件，则需要在每个文件中定义const或者使用extern关键字来声明const变量

如果想在多个文件中共享 const 对象，必须在变量的定义之前添加 extern 关键字

2.4.1 const 的引用

把引用绑定到const变量上，和绑定到其他变量一样，这种叫做对常量的引用。对常量的引用不能去修改其绑定的变量的值

const int ci = 1024;
const int &ri = ci;  // 正确： 引用及对应的变量都是常量
ri = 42;        // 错误： ri是对常量的引用，不能改值
int &r2 = ci;   // 错误： 试图将一个非常量引用指向一个常量变量

初始化和对const的引用 引用那节提到，引用的类型必须与所引用的变量一致，但是有两个例外：

• 在初始化常量引用时，允许用任意引用任意类型的变量，且可以使用任意表达式或值来初始化引用

double dval = 3.14;
const int &ri = dval;

/* 编译器编译时，实际上的运行 */
double dval = 3.14;
const int temp = dval;
const int &ri = temp;

在这种情况下，ri绑定了一个临时量 temporary变量（即编译器为暂存表达式求值结果临时创建的一个未命名的变量）

对const的引用可能引用一个并非const的对象 常量引用仅对引用自身可进行的操作进行限定，对于引用的对象是否是常量不做限制。

int i = 42;
int &r1 = i;    // 引用r1绑定对象i
const int &r2 = i;  // r2也绑定对象i，但是不允许通过r2修改i的值
r1 = 0;     // r1并非常量，i的值修改为0
r2 = 0;     // 错误，r2是一个常量引用

r2可以绑定非常量变量i，但是不能通过引用修改i的值。i的值可以通过其他操作来改变，比如直接通过i改变，用&r3引用i, 改r3

2.4.2 指针和const

指向常量的指针

• 指针也可以指向常量和非常量
• 指向常量的指针不能用于改变其所指变量的值
• 常量变量的地址只能用指向常量的指针存放

const double pi = 3.14;     // pi 是常量
double *ptr = π          // 错误，不能用非指向常量的指针针存放常量变量的地址
const double *ptr2 = π   // 正确，指向常量的指针可以存放常量变量的地址
*ptr2 = 3.04                // 错误，不能操作常量指针去改变其所指变量的值

和常量引用一样，指向常量的指针只规定不能操作常量指针来改变指向的非常量的值，不限制其他途径来改变这个非常量的值。

试试这样想：常量的指针和引用，不过是指针或引用的“自以为是”，它们觉得自己指向的是一个常量，所以自觉地不去改变所指对象的值。

const指针 常量指针 常量指针必须初始化，一旦初始化常量指针的所指地址不能改变。

int i = 0;
int i2 = 0;
int *const constPtr = &i;   // 常量指针constPtr，将一直指向i
const int ptrToConst = &i;   // 常量指针constPtr
const int constPtrToConst = &i;     // 指向常量的常量指针，既不可以改变所指变量的值，也不可改变所指地址

constPtr = &i2;              // 错误，常量指针不可改变所指变量
ptrToConst = &i2;            // 正确，指向常量的指针可以改变所指变量

2.4.3 顶层const

• 顶层const
• 底层const

What are top-level const qualifiers? You should look at top and low level const through references and pointers, because this is where they are relevant.

int i = 0;      // 普通变量
int *p = &i;    // 普通指针
int *const cp = &i;     // 普通变量
const int *pc = &i;
const int *const cpc = &i;

In the code above, there are 4 different pointer declarations. Let’s go through each of these,

int *p : Normal Pointer can be used for making changes to the underlying object and can be reassigned.

int *const cp (top-level const): Const Pointer can be used for making changes to the underlying object but cannot be reassigned. (Cannot change it to point to another object.)

const int *pc (low-level const): Pointer to Const cannot be used for making changes to the underlying object but can itself be reassigned.

const int *const cpc (both top and low-level const): Const Pointer to a Const can neither be used for making changes to the underlying object nor can itself be reassigned.

Also, top-level const is always ignored when assigned to another object, whereas low-level const isn’t ignored.

int i = 0;
const int *pc = &i;
int *const cp = &i;

int *p1 = cp; // allowed
int *p2 = pc; // error, pc has type const int*

C++ Primer has a lot of information about the same!!!

（顶层还是底层const与标识符位置无关，与是否能改变变量的值有关，能改自身，但不能改指向的变量是底层(指向常量的指针)，不能能改自身，但能改指向的变量是顶层（普通const类型、常量指针），既不能改自身，又不能改指向的变量既是顶层也是底层）

对于指针来说，顶层const int *const pit = &i; 表示指针本身是一个常量，而底层const const int ptr = &i; 表示指针所指的变量是一个常量。

一般的，顶层const可以表示任意的变量是常量，对于任何数据类型都适用，如算术类型、类、指针等 底层const则与指针的和引用等复合类型的基本类型部分有关。特殊的是指针类型既可以是顶层const也可以是底层const

int i = 0;
int *const p1 = &i; // 不能改变p1的值，这是一个顶层const
const int ci = 42;  // 不能改变ci的值，这是一个顶层const
const int *p2 = &ci; // 允许改变p2的值这是一个底层const

2.4.4 constptr 和常量表达式

常量表达式 const expression是指值不会改变并且在编译过程就能得到计算结果的表达式。

字面值、用常量表达式初始化的const变量都是常量表达式。

一个变量是不是常量表达式，由它的数据类型和初始值共同决定。

const int max_files = 20;   // 是常量表达式
const int limit = max_files + 1;    // 是常量表达式
int size = 27;    // 不是是常量表达式
const int width = getWitdh();    // 不是是常量表达式

/*  尽管size的初始值是个字面值常量，但是不是用const声明，所以不是常量表达式*/
/* 尽管width使用const声明，但它的具体值在运行时决定，所以它不是常量表达式 */

常量表达式：

• 使用const声明
• 值在编译时候能够确定

C++语言中有几种情况需要用到常量表达式：

constptr 变量

在复杂工程中，很难分辨（几乎不能）一个初始值到底是不是常量表达式。

C++11中使用constexpr来验证变量的值是否是一个常量表达式。当变量声明的表达式是一个常量表达式时，constexpr声明才是一个正确的声明。

constexpr int mf = 20;  // 20是常量表达式
constexpr int limit = mf + 1;   // mf+1是常量表达式
constexpr int sz = size();  // 只有当size是一个constptr函数时才是一条正确的声明语句

• 不能使用普通函数作为constexpr变量的初始值
• C++新标准允许使用一种特殊的constexpr函数，这种函数足够简单以至于在编译时就可以计算其结果，可所以可以用来初始化constexpr变量

字面值类型

常量表达式的值需要在编译时就得到计算，因此对声明constexpr时用到的类型必须由所限制。这些类型一般比较简单，值也显而易见，容易得到，就把它们称为“字面值类型”

• 目前接触过的算术类型、引用和指针都属于字面值类型
  • 指针定义的constexpr,初始值必须是nullptr、0或者有固定地址的变量

函数体内定义的变量一般来说不是存放在固定地址中的，而定义于函数体外的变量的地址固定不变。另外6.1.1介绍了在函数中定义有效范围超出函数本身的变量，这种变量也有固定的地址

- 引用也只能绑定到由固定地址的变量

• 自定义类Sales_Item()、IO库、string类型则不属于字面值类型，也就不能被定义成 constexpr
• 其他的一些字面值在7.5.6节介绍

指针和constexpr 在 consrexpr 声明中如果定义了一个指针，限定符 constexpr 仅对指针有效，与指针所指的对象无关

const int *p = nullptr; // p是一个指向整型常量的指针
const int *q = nullptr; // q是一个指向整型常数的常量指针

p和q的类型相差甚远，p是一个指向常量的指针，q是一个常量指针，其中constexpr把定义的变量置为了顶层const

与其他常量指针类似，constexpr指针既可以指向常量也可以组织向一个非常量

constexpr int *np = nullptr;    // np是一个指向整数的常量指针，其值为空
int j = 0;  
constexpr int i = 42;   // i是一个整型的常量
constexpr const int *p = &i;    // p是一个指向整型常量的常量指针
constexpr int *p1 = &j; // p1是一个指向整型变量的常量指针

2.5 处理类型

程序越复杂，用到的类型也随之复杂。

• 类型名难于”拼写”，难记且易写错，无法明确体现变量的真实目的及含义
• 有时候搞不清楚到底需要什么类型，需要回头从程序上下文中寻找

2.5.1 类型别名

类型别名 type alias是一个名字，它是某种类型的同义词。

使用类型别名的好处：

• 使复杂的名字简单明了
• 易于理解和使用
• 有助于程序员清楚该类型的真实目的

使用类型别名的两种方式：

• 关键字 typedef
• 别名声明(alias declaration) using

// myDouble是double的别名
typedef double myDouble;

// yourDouble是double的别名, *myPtrDouble是double * 的别名
typedef myDouble, yourDouble, *myPtrDouble;

using myInt = int;  // myInt是int的别名

使用别名

myInt n = 1;
myDouble m = 3.14;  

指针、常量和类型别名 如果某哥类型别名指代的是复合类型或常量，那么它用到的声明语句里就会产生意想不到的后果(误解)。

typedef char *pstring;      // *pstring 是 char*的别名
const pstring cstr = 0;     // cstr是指向char的常量指针
const pstring *ps;          // ps是一个指针，指向一个指向char的常量指针

const pstring 是指向char的常量指针，而非指向常量字符的指针 遇到一条使用了类型别名的声明语句时，人们往往会错误地尝试把类型别名替换成它本来的样子，以理解该语句的含义。

const char *cstr = 0;   // 这才是一个指向常量字符的指针

记住：const 是对给定类型的修饰

2.5.2 auto类型说明符

编程时常常需要吧表达式的值赋给变量，这就要求在声明变量的时候清楚的知道表达式的类型。然而要做到这一点并不容易，有时甚至根本做不到。为了解决这个问题，c++11新标准引入 auto 类型说明符，使用它可以让编译器替我们分析表达式的类型

auto 类型让编译器通过初始值来推算变量类型，显然 auto 定义的变量必须要有初始值。

auto item = val1 + val2;
// item 初始化为val1 和 val2相加的结果
// 编译器通过val1 和 val2相加的结果可以推算出item的类型

如果val1 和 val2都是int，则item的类型就是int 如果val1 和 val2都是double，则item的类型就是double

使用auto也可以在一条语句中声明多个变量，由于一条声明语句只能有一个基本数据类型，所以一条语句中的基本数据类型必须一致。

auto i = 0, *p = &i;    // 正确,i是整型数字,p是整型指针
auto sz = 0, pi = 3.14;  // 错误： sz和pi的类型不一致

复合类型、常量和auto 有时编译器推断出的auto类型和初始值的类型并不一样，因为编译器会根据初始化的规则做一些自动的转换

比如使用引用其实是使用引用（绑定）的变量，特别是在引用被用做初始值时，真正参与初始化的是引用（绑定）的变量。此时编译器使用引用（绑定）的变量的类型作为 auto 的类型

int i = 0, &r = i;
auto a = r;         // a是一个整型变量

其次auto一般会忽略顶层const，且保留底层const.

const int ci = i, &cr = ci;
auto b = ci;        // b是一个整型变量（ci的顶层const特性被忽略掉了）
auto c = cr;        // c是一个整型变量（cr是ci的别名，ci的顶层const特性被忽略掉了）
auto d = &i;        // d是一个整型指针
auto e = &ci;       // e是一个指向整型常量的指针（对常量取地址是一种底层const）

如果希望推断出的auto是一个顶层const, 需要明确指出

const auto f = ci;  
// ci的推演类型是一个int, f是const int
// f是一个整型常量

还可以将引用的类型设为auto，原来的（引用）初始化规则仍然适用。

auto &g = ci;       // g是一个整型常量引用，绑定到ci
auto &H = 42;       // 错误，不能为非常量引用绑定字面值
const auto &j = 42;    // 正确，可以位常量引用绑定字面值

声明一个auto类型的引用，初始值中的顶层常量属性仍然保留

/* 再次提醒，一条声明中的*和&只从属于紧跟的那个声明符号 */
/* 且一条声明中的类型必须一致 */

auto k = ci, &l =i;     // k是整型，l是整型引用
auto &m = ci, *p = &ci; // m是对整型的引用，p是指向整型常量的指针
auto &n = i, *p2 = &ci; // 错误，i是的类型int, &ci的类型是const int

2.5.3 decltype类型指示符

有时会遇到这种情况：希望从表达式的类型推断出要定义的变量的类型，但是不想用该表达式的值初始化变量。

为了满足这个需求，c++11引入 decltype 。它的作用是选择并返回操作数的数据类型。在此过程中，编译器分析表达式并得到它的类型，却不实际计算表达式的值。

decltype(f()) sum = x;  // sum的类型就是函数f的返回值类型

编译器并不实际调用函数f，而是使用当调用发生时的f的返回值类型作为sum的类型

如果decltype使用的表达式是一个变量，则decltype返回该变量的类型（包括顶层const和引用在内）

const int ci = 0, &cj = ci;
decltype(ci) x = 0;     // x的类型是const int
decltype(cj) y = x;     // y的类型是const int &, y绑定到变量x
decltype(cj) z;         // 错误, z是一个引用，必须初始化

需要指出的是, 引用从来都作为变量的同义词出现，只有用在decltype处是一个例外

decltype和引用 如果decltype使用的表达式不是一个变量，则decltype返回表达式结果对应的类型。

// decltype的结果可以是引用类型
int i = 42, *p = &i, &r = i;
decltype(r+0) b;      // 正确，加法的结果是int，因此b是一个（未初始化的）int
decltype(*p) c;     // 错误，c是int&，必须初始化

r是一个引用, 所以decltype(r)的结果会是引用类型。 而decltype(r+0)的结果是int，因为r作为表达式的一部分，r+0的结果显然是一个int。

对于decltype(*p)中, *p是对指针的解引用，得到的是指针所指的变量，还可以以此操作此变量（给变量赋值），相当于引用，所以是int&。

decltype的结果类型与表达式形式密切相关，有一种需要特别注意就是变量名加括号的形式，加与不加括号的类型不同：

// decltype的表达式如果是加上括号，结果类型将是引用
decltype ((i)) d;   // 错误： d是int&，必须初始化
decltype (i) e;     // 正确： e是一个（未初始化的）int

decltype((variable))（注意是双层括号）的结果永远是引用，而decltype(variable)结果只有当variable本身就是一个引用时才是引用

2.6 自定义数据结构

从最基本的层面理解，数据结构是把一组相关的数据元素组织起来然后使用它们的策略和方法

C++语言允许用户以类的形式自定义数据类型，而标准库类型string, istream、ostream等也都是以类的形式定义的。

C++对类的支持甚多

2.6.1 定义Sales_item类型

先实现一个简单的类，给用户提供一些可以访问的数据元素和一些基本的操作。 由于是简单的实现，不妨将他叫做 Sales_data

struct Sales_data {
    std::string bookno;
    unsigned unit_sold = 0;
    double revenue = 0.0;
}

这个类以关键字 struct 开始，紧跟着类名和类体（其中类体部分可以为空）。 类体由花括号包围形成了一个新的作用域，类内部定义的名字必须唯一，但是可以与类外部定义的名字重复。 类体右侧的表示结束的花括号后必须写一个分号（因为类体后面可以紧跟变量名以示对该类型的定义，所以分号必不可少）

struct Sales_data { /* ...  */} accum,trans,*salesptr;

struct Sales_data { /* ...  */};    // 和上一条语句等价，但可读性更好一些
Sales_data accum,trans,*salesptr;

分号表示声明符的结束，一般来说最好不要把变量的定义和类的定义放在一起。

struct MyClass{
    int cnt;
    double sum = 0.0;
};

记住在类的定义之后加上分号

类数据成员 类体定义类的成员，我们上面定义的类只有数据成员 data member。

类的数据成员定义了类的实例的具体内容，每个实例有自己的一份数据拷贝。修改一个实例的数据成员，不会影响其他实例。

定义数据成员的方法和普通变量一样：一个基本类型后面紧跟一个或者多个声明符。

我们上面定义的类 Sales_data 有三个数据成员, 每个 Sales_data 的实例都将包含这3个数据成员

C++11标准规定，可以为类数据成员提供一个类内初始值 in-class initializer。创建实例时，类内初始值将用于初始化数据成员。没有初始化的成员将会被默认初始化（2.2.1 默认初始化）

当定义Sales_data的实例时，unit_sold和revenue都将初始化为0, bookno会被初始化为空字符串。

对类内变量的初始化限制与2.2.1介绍的类似，初始值置于花括号内或者等号右侧，但区别是不能使用圆括号来初始化。

7.2节将会介绍使用C++提供的另一个关键字 class 来定义自己的数据结构。到时也会说明 struct 和 class 定义类的区别

2.6.2 使用Sales_data类

我们自定义的Sales_data类(内部)没有提供任何操作，想要执行任何操作就要自己动手实现。

struct Sales_data {
    std::string bookno;
    unsigned unit_sold = 0;
    double revenue = 0.0;
}

我们将写一段简易的求两次交易相加结果的功能。 程序的输入是两条交易记录：

0-201-78345-x 3 20.0
0-201-78345-x 3 25.0
# ISBN编号 售出数量 售出单价

已同步到cppStart项目

#include <iostream>
#include <string>
// #include <Sales_data.h> /* 若Sales_data定以在另一个头文件Sales_data.h内 */
struct Sales_data {
    std::string bookNo;
    unsigned unit_sold = 0;
    double revenue = 0.0;
};

struct Sales_rs {
    std::string bookNo;
    unsigned totalCnt = 0;
    double totalRevenue = 0.0;
};

void getSales_data(Sales_data &d) {
    using namespace std;
    double price = 0.0;
    cin >> d.bookNo >> d.unit_sold >> price;
    d.revenue = d.unit_sold * price;
}

int computeSales_data(Sales_data &d1, Sales_data &d2, Sales_rs &rs) {
    using namespace std;
    if (d1.bookNo != d2.bookNo) {
        
        return -1;
    }
    rs.bookNo = d1.bookNo;
    rs.totalCnt = d1.unit_sold + d2.unit_sold;
    rs.totalRevenue = d1.revenue + d2.revenue;
    cout << "ISBN：" << rs.bookNo << " 总销售量:" << rs.totalCnt << " 总销售额"
         << rs.totalRevenue << endl;

    if (rs.totalCnt != 0) {
        cout << "平均价格" << rs.totalRevenue / rs.totalCnt << endl;
    } else {
        cout << "no sales" << endl;
    }

    return 0;
}

int main() {
    using namespace std;
    cout << "Start \n";
    /* 声明两个Sales_data实例 */
    Sales_data d1, d2;

    /* 读入两条数据 */
    getSales_data(d1);
    getSales_data(d2);

    /* 输出两条数据的和 */
    Sales_rs rs;
    int hasError = computeSales_data(d1, d2, rs);
    if (hasError != 0) {
        cout << "计算出错" << endl;
        return -1;
    }

    // cout << d1.revenue << " " << d2.revenue << endl;

    cout << "End \n";
    return 0;
}

2.6.3 编写自己的头文件

尽管之前讲到的大多数是在函数内部定义类，但是这样定义的类（作用范围，复用性）毕竟受到了一些限制。

常规操作的类都不会定义在函数内部，而是（为了复用）通常被提取到一个头文件中，而且头文件的名字应该与类的名字一样。例如标准库类型string的头文件名也是string，Sales_data头文件名也应对应为Sales_data.h。

头文件通常包含那些只能被定义一次的实体，如类，const和constptr变量等。

头文件中也可能会用到其他头文件。如Sales_data中会用到标准库string，所以Sales_data.h中需要包含string.h头文件。

而其他用到Sales_data的文件也有可能使用string.h, 此时需要在书写头文件时做适当的处理预处理器，使其遇到多次包含的情况也能安全和正常的工作。

头文件一但改变，相关的源文件需要重新编译来获取更新过的声明。

预处理器概述 通常用于确保多次包含头文件仍能安全工作，是C++从C语言中继承的特性。

预处理器是在编译之前执行的一段程序，可以部分的改变我们所写的程序。如已经使用过的 #include ，预处理器看到 #include 标记时就会用指定的头文件内容代替 #include C++中另一个常用的预处理功能是头文件保护符 header guard，头文件保护符依赖于预处理变量。 预处理变量有两种状态： 已定义和未定义 #define 指令把一个名字设定预处理变量 另外两个指令则分别检查某个指定的预处理变量是否已经定义

• #ifdef 当且仅当变量已经定义时为真
• #ifndef 当且仅当变量未定义时为真
• 一旦命中某个条件则一直执行到 #endif 指令为止

/* 
 Sales_data.h 通过预处理变量判断后
 不管被多少个文件使用，都只会定义一次Sales_data
 标准库string肯定也做了类似的处理
*/
#ifndef SALES_DATA_H    
#define SALES_DATA_H    /* 定义一个预处理变量 */
#include <string>
struct Sales_data {
    std::string bookno;
    unsigned unit_sold = 0;
    double revenue = 0.0;
};
#endif

第一次使用， #ifndef 为真，预处理器将顺序执行到 #endif 为止，此时预处理变量 SALES_DATA_H 的值将变为已定义，而 Sales_data.h 也会被拷贝到程序中来。

后面如果再次包含 Sales_data.h ，则 #ifndef 为假，编译器将忽略 #ifndef 到 #endif 的部分。

预处理变量无视C++语言中关于作用域的规则

整个程序中的预处理变量和头文件保护符都必须唯一，通常基于头文件名或者头文件中类名来命名头文件保护符，以确保其唯一性。

为了避免和程序中其他实体名字发生冲突，一般把预处理变量全部大写。

不管程序需不需要，头文件保护符应该习惯性的加上。加头文件保护符很简单，也提高了代码健壮性

第三章 字符串、向量和数组

除了第二章介绍的内置类型之外，C++语言还定义了一个内容丰富的抽象数据类型库，比如string和vector是两种最重要的标准库类型，前者支持可变长字符串，后者则表示可变长集合。 还有一种标准库类型是迭代器，它是string和vector的配套类型，常被用于访问string中的字符或vector中的元素

内置的数组是一种更基础的类型，string和vector都是对它的某种抽象。

第二章介绍的内置类型是由C++语言直接定义的，这些类型，比如数字和字符，提现大多数计算机硬件本身具备的能力。

标准库定义了另外一组具有更高级性质的类型，它们尚未直接实现到计算机硬件中。

内置数组类型和其他内置类型一样，数组的实现与硬件密切相关，因此相较于标准库类型string、vector等在灵活性上稍显不足

3.1 命名空间的using命名

目前为止我们用到的库函数基本上都属于命名空间std，程序中也显示地表示了，比如 std::cin 表示从标准输入中读取内容，此处使用的作用域操作符 :: 的含义是：编译器应从操作符左侧名字所示的作用域中寻找右侧那个名字。

std::cin 表示使用 std 中的 cin 另外一种更简单也更安全的方法是使用 using 声明

using namespace::name;

using std::cin; 
using std::cout; using std::endl;

#include <iostream>

/* using声明，当我们使用名字cin时候，从命名空间std中获取它 */
using std::cin;

int main() {
    int i;
    cin >> i; // 正确：cin和std::cin含义相同
    cout << i; // 错误：没有对应的using声明，必须使用完整的名字
    std::cin >> i;  // 正确
    std::cout << i; // 正确,显式地从std中使用cout
    return 0;
}

每个名字都需要独立的using声明

/* 每个名字都需要有自己的声明语句，且每个声明按逗号分隔 */
using std::cin;
using std::cout; using std::endl;

/* 
    或者使用 
    using namespace std;
*/

头文件不应包含using声明 位于头文件的代码，一般来说不应该使用using声明。 这是因为头文件的内容会拷贝到所有引用它的文件中去，如果头文件中有某个using声明，那么每个使用了该头文件的文件就都会有这个声明。

由于不经意间包含了一些名字，所以容易产生无法预料的名字冲突。

3.2 标准库类型string

标准库类型 string 表示可变长的字符序列 使用 string 类型必须引入 string头文件 作为标准库的一部分， string 定义在命名空间 std 中

#include <string>
using std::string;

3.2.1 定义和初始化string对象

常用的一些方式：

string s1;          // 默认初始化,s1是一个空字符串
string s2 = s1;     // s2是s1的副本
string s3 = "hiya"; // s3是该字符串字面值的副本
string s4(5, 'c');  // s4的内容是 ccccc

/* 
    注意“”是字符串，''是单个字符
    在C++语言中是有区别的
 */

直接初始化和拷贝初始化

string s5 = "hiya"; // 拷贝初始化，内容是hiya
string s6("hiya");  // 直接初始化，内容是hiya
string s7(5, 'c');  // 直接初始化，内容是ccccc

拷贝初始化，编译器把等号右侧的初始值拷贝到新创建的变量上去

3.2.2 string对象上的操作

string的主要操作：

读写string对象 可以使用IO操作符读写string对象

string s;   // 空字符串
cin >> s;   // 将string对象读入s,遇到空白为止
cout << s << endl;  // 输出s

cin写入string类型时候，string类型会自动忽略开头的空白(空格、换行符、制表符等)，从第一个真正的字符开始读起，直到遇见下一个空白为止。

程序输入的” hello “，则输出的将是”hello”，输出结果中不包含任何空格

和内置的输入输出操作一样，string对象的此类操作也是返回运算符左侧的运算对象作为结果。因此多个输入输出可以连写在一起。

string s1, s2;
cin >> s1 >> s2;           // 把第一个输入读到s1中，第二个读到s2中
cout << s1 << s2 << endl;   // 输出两个string对象

读取未知数量的string对象

int main() {
    string word;
    while(cin >> word){     // 反复读取，直到到达文件末尾（或者Ctrl-D for unix/linux, Ctrl-Z for windows ）
        cout << word << endl;   // 逐个输出，每个输出后换行
    }
    return 0;
}

使用getline读取一整行 如果希望在最终得到的字符串中保留输入中的字符串，则应该用 getline 函数而不是用 >> 操作符。

getling 函数的参数是一个输入流和一个string对象， 函数从给定的输入流中读入内容，直到遇到换行符为止（注意换行符也被读进来了）

然后把读取到的内容存入到string对象中（注意不存换行符）。

getline 只要一遇到换行符就结束读取操作并返回结果，哪怕输入一开始就是换行符也是如此。（一开始就是换行符的情况，所得的结果string是个空string）

和输入运算符 >> 一样，getline也会返回它的流参数。 所以可以作为判断的条件：

int main() {  
  string line;

  while (getline(cin, line)) {
    cout << line << endl;   // Line中不包含换行符，所以我们手动加上换行符
  }
  return 0;
}

string的empty和size操作 empty 根据 string 对象是否为空返回一个对应的布尔值

string line;
while(getline(cin, line)){
    if(!line.empty()){
        cout << line << endl;   // 只输出非空的行
    }
}

! 逻辑非运算符，它返回与其运算对象相反的结果

size 函数返回string对象的长度（即string对象中字符的个数）

string line;
while(getline(cin, line)){
    if(line.size() > 80){
        cout << line << endl;   // 只输出超过80个字符的行
    }
}

string::size_type类型 size 函数返回的就是 string::size_type 的值

string 类及其他大多数标准库类型都定义了几种配套的类型。这些配套类型体现了标准库类型与机器无关的特性，类型size_type即是其中的一种。

string::size_type 是一个无符号类型的值，而且能够存放下任何string对象的大小。

在cpp11中可以使用auto或者decltype来推断变量的类型

auto len = line.size(); // len的类型是string::size_type

size 函数返回的是一个无符号整型数，因此切记注意在表达式中尽量不要混用带符号数和无符号数字

如果一条表达式中已经有了size()就不要使用int了，这样可以避免混用int和unsigned可能带来的问题

比较string对象 比较运算符逐一比较string对象中的字符，并且对大小写敏感

相等性运算符( == 和 != ), 校验两个string对象相等或者不等，相等意味着长度和包含的字符完全相同

关系运算符（ < 、 <= 、 > 、 >= ）的校验都依照（大小写敏感的）字典顺序：

• 长度不同比较长度
• 长度相同，字符位置不同，比较第一对相异字符的比较结果

string a = "abc";
string b = "abcd";

string c = "abc";
string d = "agc";

a<b     // true
c<d     // true 比较第一个相异字符顺序 区分大小写

为string对象赋值

在设计标准库类型时在易用性上都力求向内置类型看齐，因此大多数标准库都支持赋值操作

对于string类而言，允许把一个string对象赋值给另一个对象

string s1(10,'c'), s2;
s1 = s2;        // 将s2的值赋给s1
                // 此时s1，s2都是空字符串

两个string对象相加 string对象相加就是把string对象串接起来，结果是一个新的string对象（+=也是等价的）

string s1 = "hello,  " , s2 = " world\n";
string s3 = s1 + s2;    // s3 :"hello, world\n"
s1 += s2;       // s1 :"hello, world\n"

字面值和string对象相加 注意：字面值不能直接相加，只能是字面值+string对象

string s1 = "hello,  " , s2 = " world\n";
string s3 = s1 + "\n" + s2 + "end\n";    // s3 :"hello, world\n"

string s4= s1 + "\n"  + "end\n";    // 错误，字面值不能直接相加
string s5= "\n"  + "end\n";    // 错误，字面值不能直接相加
string s6= "\n"  + "end\n" + s1;    // 错误，字面值不能直接相加

• Concatenate two string literals
• C++ 14 real string literals

因此某些历史原因，也为了和C兼容，所以C++语言中的字符串字面量不是标准库类型string的对象(而是c-string)。

切记字符串字面值与string是不同的类型

3.2.3 处理string对象中的字符

我们经常需要单独处理string对象中的字符，比如检查一个string对象是否包含空白，或者把string对象中的字母改成小写，再或者查看某个特定的字符是否出现等等。 处理这些问题常常要涉及到语言和库的很多方面

在cctype头文件中定义了一组标准库函数来处理这部分工作

建议使用C++版本的C标准库头文件

C++标准库中除了定义C++语言特有的功能外，也兼容了C语言的标准库。如C语言中的name.h，在C++中被命名位cname（去掉.h后缀，在文件名name之前添加了字母c，表示这是属于C语言的标准库）。在cname里面的名字从属于std，而定义在name.h中的文件则不是。

所以在C++中使用C语言的标准库时，最好使用cname的头文件而不是name.h的

处理每个字符？使用基于范围的for语句

对字符串中每个字符的操作，最好使用C++11提供的 范围for range for 语句。

范围for range for 语句遍历：

for( declaraion: expression){
    statement;
}

expression 是被遍历的序列对象 declaraion 定义一个循环变量，用于访问序列中的元素 每次迭代 declaraion 会被初始化为 expression 的下一个元素

string str("some str");
for(auto ｓ : str){
    cout << c << endl;  
    // 对于str中的每个字符，输出当前字符和一个换行符
}

for循环把变量c和str联系了起来，其中定义循环变量的方式和定义任意一个普通变量是一样。上例中使用auto关键字让编译器来决定变量c的类型（上例子中c的类型是char）。

// 使用范围for和ispunct函数来统计string对象中标点符号的个数
#include <iostream>
#include <string>
#include <cctype>

int main() {
    using std::cout;
    using std::string;
    using std::ispunct;

    string s = ",'Hello World!!!";
    decltype(s.size()) puncCount = 0;

    for (auto c : s) {
        if (ispunct(c)) {
            puncCount++;
        }
    }
    cout << puncCount << " punc in" << s;
    return 0;
}

代码中使用decltype来使编译器决定puncCount的类型，即s.size函数返回值的类型，也就是string::size_type

使用范围for语句改变字符串中的字符

如果想要操作范围for中的循环变量，则需要把循环变量定义为引用类型。 这样循环变量实际上被依次绑定到循环序列的每个元素上，我们就可以使用这个引用来操作对应的字符。

#include <iostream>
#include <string>
#include <cctype>

int main() {
    using std::cout;
    using std::endl;
    using std::string;
    using std::toupper;
    // cout << "Hello Wolrd\n";
    string s = "Hello Wolrd";
    for (auto &c : s) {
        c = toupper(c);
    }
    cout << s << endl;
    return 0;
}

只处理一部分字符

要想访问string对象中单个字符有两种方式：

• 使用下标运算符 []
• 使用迭代器(3.4节和第九章介绍)

这里只介绍下标运算符 []

• 接收的参数是 string::size_type 类型的值，表示要访问的字符的位置
• 返回值是该位置上字符的引用
• string对象的下标从0开始（s[s.size()-1]取最后一个字符）

string对象的下标参数必须大于等于0, 且小于s.size()

超出此范围的下标将会引发不可预知的结果，以此推断，使用下标访问空string也会引发不可预知的结果

下标的值称作下标或者索引，任何表达式只要是整型就能作为索引，不过带符号类型的值将自动转换成string::size_type（无符号类型）

// 输出string的第一个字符
if(!s.empty()){     // 确保string非空
    cout << s[0] << endl;
}

只要字符串不是常量，就可以直接使用下标来操作字符

string s("some string");

if(!s.empty()){
    s[0]=toupper(s[0]);     // 将s的第一个字符改为大写
}
cout << s << endl;      // 输出Some string

使用下标执行迭代

string s("some string");

for( decltype(s.size()) idx=0;
     index != s.size() && !isspace(s[idx]);
     ++idx;  
   ){
        s[idx] = toupper(s[idx]);
   }
//    输出 SOME string

for循环中使用了逻辑与运算符号( && )

下标必须大于等于0小于等于字符串的size()。简单的做法是总是设置下标的类型为string::size_type, 因此类型是无符号数，可以确保下标不会小于0, 我们只需要保证下标小于size()就可以了

C++标准库并不要求检测下标是否合法，所以不能在编译阶段检查出下标越界的情况，一旦在程序运行时候使用了一个超出范围的下标就会产生不可预知的结果

使用下标执行随机访问 之前只使用下标进行从前往后的顺序访问，其实下标也可以不按顺序，随机访问

/* 
    把0到15之间的十进制数字转换成对应的十六进制数字
 */
#include <iostream>
#include <string>

int main(){
    using std::string;
    using std::cout;
    using std::cin;
    using std::endl;

    const string hexDigits = "0123456789ABCDEF";     // 可能的十六进制数字(0-15)

    cout << "Enter a series of numbers between 0 and 15"
         << " seperated by space. Hit ENTER when finished:"
         << endl;

    string hexRes;                                  // 用于保存转换的十六进制结果
    string::size_type n;                            // 用于保存从输出流读取的数

    while(cin >> n){
        if(n<hexDigits.size()){
            hexRes += hexDigits[n];
        }
    }

    cout << "Your hex number is:" << hexRes << endl;
    return 0;
}

把 hexDigits 声明为常量是因为在后面的程序中不会再去修改它的值（相当于一个数字转16进制的映射表）

无论何时用到字符串的下标，都应该注意检查其合法性

3.3 标准库类型vector

标准库类型 vector 表示对象的集合，其中所有对象的类型都相同。

vector 存储的每个对象都有个 索引 ，用于访问对象 因为 vector 容纳着其他对象，所以也经常被称为容器

使用 vector 需要包含头文件 #include <vector> , 且名称在 std 中

#include <vector>
using std::vector;

C++语言既有类模板 class template ，也有函数模板。 vector是一个类模板

只有对C++有了相当深入的了解才能写出模板，在16章才开始学习模板。幸运的是，即使不会创建模板，也可以使用它

模板本身不是类或者函数，可以将模板看做用于编译器生成类或者函数的一份说明。编译器会根据模板创建类或者函数，这个过程称为 实例化 ，当使用模板时候，需要指出编译器应把类或函数实例化成什么类型。

对于类模板，比如 vector ，需要使用尖括号来指定实例的类型

vector<int> myVec;      // myVec保存int类型元素
vector<double> myDoubleVec; // myVec保存double类型元素
vector<custom_item> myCustomVec;   // myVec保存自定义的类型元素
vector<vector<string>> myVecVec;   // myVec保存vector类型 的 类型元素，类似于二维数组
[
    ["abc"],
    ["a","b"],
]

vector是模板，而非类型，使用vector必须指定元素类型，比如 vector<string> 。由vector生成的元素必须是vector尖括号指定的类型。

vector可以容纳绝大多数类型的变量，不过由于引用不是变量，所以不存在包含引用的vector。

早期的C++版本（C++11以前）或者某些不常见的编译器中，嵌套的vector需要一个空格如 vector<vector<int> >

3.3.1 定义和初始化vector对象

默认初始化创建的是一个指定类型的空vector：

vector<string> strvec;  // 默认初始化，strvec不包含任何元素

最常见的方式就是先定一个空vector，然后在需要的时候��里面添加元素。

也可以把一个vector，直接赋值给另一个vector，不过注意类型必须一致

vector<int> ivec;
// 向ivec添加一些元素

vector<int> ivec2(ivec);    // 把ivec的元素拷贝给ivec2
vector<int> ivec3= ivec;    // 把ivec的元素拷贝给ivec3
vector<string> svec(ivec2);    // 错误，类型不一致

列表初始化vector对象 cpp11

vector<string> articles = {"a", "an", "the"};
vector<string> articles{"a", "an", "the"};
vector<string> articles("a", "an", "the"); // 错误，圆括号

创建指定数量的元素 使用统一的初始化来初始化vector对象

vector<int> ivec(10, -1)    // 10个int类型的元素，每个都被初始化为-1
vector<int> ivec(10, "hi")    // 10个int类型的元素，每个都被初始化为"hi"

值初始化 vector初始化时可以只指定数量，而不指定值，值就初始化为指定的类型的对应初始值

vector<int> ivec(10);     // ivec初始化为10个0
vector<string> ivec(10);     // ivec初始化为10个空字符串

vector<int> ivec = 10;  // 错误，这样赋值只能将一个vector传给另一个vector，或者使用列表初始化

这样的初始化有些限制：有些类型要求必须提供初始值，就必须提供初始值的对象

列表初始值还是数量？ 注意区分花括号 {} 和圆括号 () 初始化的不同

• 圆括号 (数量，值)
• 花括号 {元素，元素}
  • 如果花括号提供的元素不符合指定的元素，则编译器会尝试使用圆括号来执行这些值
  • 所以最好是避免混用和指定对类型

3.3.2 向vector对象中添加元素

vector 成员函数 push_back ，负责把一个值推到一个 vector 的尾部

向 vector 推入100个元素：

vector<int> myVec;
for (int i = 0; i != 100; ++i) {
    myVec.push_back(i);
}

另一个例子，在运行时才确定向 vector 推入多少个元素:

vector<string> strVec;
string tmp;
cout << "请输入一些需要存放的文字，以空格分隔，ctrl+D结束"
     << endl;
while(cin >> tmp){
    strVec.push_back(tmp);
}   

C++标准要求vector可以高效的添加元素（C语言中的数组需要初始大小，不能动态增加元素）。所以给vector初始化时候设置其大小也就没什么必要了，反而会降低效率(除非所有元素的值都一样，初始时指定大小才不会降低vector性能)。第9.4将介绍vector提供的进一步提升动态添加元素性能的方法。

向vector对象添加元素蕴含的编程假定

由于可以高效便捷地向vector中添加元素，许多编程工作都被简化了。 不过这样就得保证所写的循环正确无误，特别是在需要改变vector的元素数量的时候

随着对vector更多的了解，我们可以知道如果需要在循环中改变vector元素数量，则不能使用 范围for

范围for 语句内不应该改变所遍历的序列的大小

3.3.3 其他vector操作

其他vector操作大多数与string类似，下面列举的常用部分：

访问vector中元素的方法和访问string中字符的方法差不多

vector<int> v{1,2,3,4,5,6,7,8,9};
for(auto &i : v){
    i *= i;         // v中每个元素取平方
}

for(auto i : v){
    cout << i << " ";         // 输出v中每个元素
}
cout << endl;

vector 的成员函数 empty 和 size 与 string 完全一致， empty 返回一个布尔值，表示 vector 是否包含元素， size 返回值的类型是由 vector 定义的 size_type 类型。相等运算符和关系运算符号也与 string 的相应运算符功能一致。

vector 中元素只有其类型的值可以比较时才可以进行比较。比如自己定义的 Sales_item 类不支持相等运算和关系运算，则 vector<Sales_item> 就不可进行比较。

计算vector内对象的索引 （和 string 类似）下标也是从0开始，下标类型是对应的 size_type , 只要 vector 不是个常量，就可以通过下标直接操作对应的元素。

    using std::cin;
    using std::cout;
    using std::endl;
    using std::vector;

    /* 以10分为一个区间统计每一个区间的成绩数量 */
    vector<unsigned> scoreCnt(10, 0);   // 初始化每个区间的分数计数为0
    unsigned input = 0;
    while (cin >> input) {              // 输入成绩
        if(input<=100){                 // 只统计有效成绩
            ++scoreCnt[input/10]        // 将对应区间成绩计数+1
        }
    }

    cout << "Hello Wolrd\n";
    return 0;

++scoreCnt[input/10] 
// 等价于
int tmp = input/10;
scoreCnt[tmp] = scoreCnt[tmp] +　１;

不能使用下标形式添加元素

vector<int> v;  // 空vector对象

v[0] = 1;       // 错误
for(decltype(v.size()) idx=0; idx!=10; ++idx){
    v[idx] = idx;       // 错误
}

要向 vector 添加元素，正确的做法是使用 push_back

vector<int> v;  // 空vector对象
for(decltype(v.size()) idx=0; idx!=10; ++idx){
    v.push_back(idx);       // 错误
}

vector对象的下标可以用于访问已存在的元素，不能用于添加元素

提示，只能对确定以及存在的元素执行下标操作，用不存在的下标访问元素不会被编译器发现，而在运行时会取到一个不可预知的值。（缓冲区溢出问题）

确保下标合法的一种有效手段是尽可能使用范围for语句

3.4 迭代器介绍

我们已经知道可以使用下标运算符来访问 string 和 vector 对象的元素，还有另外一种更通用的机制也可以实现同样的机制，就是迭代器

除了 vector 以外，标准库中还定义了其他几种容器，所有标准库容器都可以使用迭代器，不过只有少数几种才同时支持下标运算符。

严格来说 string 不属于容器类型，但是 string 支持很多与容器类似的操作，比如支持 下标运算符 和 迭代器 迭代器类似于指针类型，提供了对对象的间接访问。 迭代器可以访问容器的某个元素，也可以从一个元素移动到另外一个元素，迭代器有有效和无效之分。 有效的迭代器指向某个元素或者尾元素的下一个位置，其他情况都属于无效。

3.4.1 使用迭代器

和指针不同的是，获取迭代器不是用的 取地址符号 ，支持迭代器的类型都有 begin 和 end 方法， begin 指向迭代器第一个元素

vector<int> intV = {1,2,3,4,5};
string s = "12345";
auto front = intV.begin(), end = intV.end();    // front指向第一个元素1,end指向intV尾元素的下一个位置
auto front2 = s.begin(), end2 = s.end();    // front2指向第一个字符’1‘,end2的指向尾字符的下一个位置'5'

end指向尾元素的下一个位置，通常被称为 尾后迭代器 off-the-end iterator , 尾迭代器。

若容器为空，则 begin 和 end 返回的是同一个迭代器，都是尾后迭代器（ v.begin() == v.end() ）

一般来说我们并不知道（也不在意）迭代器的准确类型是什么，所以一般使用 auto 由编译器判断就可以了

迭代器运算符

使用 == 和 != 来比较两个合法的迭代器是否相等

标准容器迭代器的运算符:

<iterator> | cplusplus

和指针类似，也可以通过解引用来获取它所指的元素。 执行解引用的迭代器必须合法，并指向其某个元素。 试图解引用一个非法迭代器，或者尾后迭代器都是未被定义的行为。

使用迭代器把字符串中第一个个字符改为大写

    string s = "some string";
    cout << "origin: " << s << endl;

    if (s.begin() != s.end()) {
        auto oneChar = s.begin();
        *oneChar = toupper(*oneChar);
    }

    cout << "result: " << s << endl;

将迭代器从一个元素移动到另外一个元素 迭代器使用 ++ 运算符来从一个元素移动到下一个元素。

整数的递增是将整数的数值加1, 迭代器的递增是将迭代器向前移动一个位置

把string对象中第一个单词（中的所有字符）转换成大写：

    /* 当遇到空格或者到迭代器尾部时候循环停止 */
    for (auto el = s.begin(); el !=s.end() && !isspace(*el) ; ++el) {
        *el = toupper(*el);
    }    
    cout << "result: " << s << endl;

原来使用C或者Java的程序员在转而使用C++语言后，会对for循环中使用!=而非<进行判断有点奇怪。C++程序员习惯性的使用!=，原因是这个判断在标准库提供的所有容器都有效。

所有标准库容器都实现了迭代器、==和!=，而许多标准库并未实现 下标操作符 和比较操作符<、>等。

所以习惯性的使用迭代器、==和!=，可以不用关心标准库容器实现，因为都实现了迭代器、==和!=

迭代器类型

拥有迭代器的标准库使用 iterator 和 const_iterator 来表示迭代器的类型。

vector<int>::iterator intV;     // intV可以读写vector<int>的元素
strnig::iterator s; // s可以读写strnig对象的元素

vector<int>::const_iterator intV2;     // intV2只能读元素，不能写元素
strnig::const_iterator s2; // s2只能读元素，不能写元素

const_iterator和常量指针差不多，可读不可写。 如果vector和string对象是一个常量，那么只能使用const_iterator 如果vector和string对象不是一个常量，那么既能使用const_iterator，也能使用iterator

迭代器这个词有三种不同的含义：可能是迭代器本身，也可能是指容器定义的迭代器类型，还可能是指某个迭代器对象

我们认定某个类型是迭代器，当且仅仅当它支持一套操作，这套操作使得我们能访问容器的元素或者从某个元素移动到另一个元素。 每个容器定义了一个名为iterator的类型，该类型支持迭代器概念所规定的一套操作

begin和end运算符

• 对象是常量，begin和end返回 const_iterator 类型
• 对象不是常量，begin和end返回 iterator 类型

vector<int> v1;
const vector<int> v2;

auto iter1 = v1.begin();        // v1的类型是 `iterator` 类型
auto iter2 = v2.begin();        // v2的类型是 `const_iterator` 类型

有时候这种默认的行为并非我们所要的，所以C++11新增了 cbegin 和 cend 来获取 const_iterator 类型,

auto iter3 = v.cbegin() // iter3的类型是vector<int>::const_iterator

cbegin 和 cend 不论 vector 对象是否是常量，返回值都是 const_iterator 结合解引用和成员访问操作

解引用迭代可获得迭代器所指的对象，如果该对象恰好是类，就有可能希望进一步访问它的成员。

例如一个string类型的迭代器：

(*it).empty()

通过解引用来访问到string对象，在调用string对象的empty()方法判断是否是一个空字符串。

注意 (*it).empty() 中的圆括号不可少，具体原因在4.1.2节介绍。 如果不加括号， . 点运算符将作用在 it 上，而不是 *it 所指的对象上

(*it).empty()       // 解引用it,然后调用结果对象的empty成员
*it.empty()         // 错误: 试图访问it的名为empty的成员，但it是个迭代器，没有empty成员

为了简化 (*it).empty() 这种解引用并访问成员的操作，C++语言定义了箭头运算符 ->

/* 两种操作等价 */
it->item
(*it).item

使用箭头运算符：

    vector<string> text = {
        "Contrary to popular belief, Lorem Ipsum is not simply random text. It "
        "has roots in a piece of classical Latin literature from 45 BC, making "
        "it over 2000 years old. ",
        "The standard chunk of Lorem Ipsum used since the 1500s is reproduced "
        "below for those interested. "};

    /* 输出text中的每段文字 */
    cout << "输出text的第一段文字:" << endl;
    for (auto el = text.cbegin(); el != text.cend() && !el->empty(); ++el) {
        cout << *el << endl;
    }

对vector的某些操作会使迭代器失效

虽然vector可以动态的增长，但是有一些副作用。

• 在范围for中不能向vector增加元素

• 另外任何一种可以改变vector容量的操作，比如 push_back , 都会使 vector 对象的迭代器失效

但凡是使用了迭代器的循环体，都不要向迭代器所属的容器中添加元素

3.4.2 迭代器运算

迭代器的递增操作使迭代器每次移动一个元素，所有标准库容器都支持迭代器的递增操作 + 。（也都支持 == 和 != ）

string 和 vector 的迭代器提供了更多的运算符

迭代器的算术运算 可以使迭代器和一个整数值相加减，得到的结果是向前（或者后）移动了相应位置的迭代器

/* 计算得到vi迭代器中间位置的迭代器 */
auto mid = vi.begin() + vi.size() / 2;

/* 即：如果vi有20个元素，以上操作得到第11个元素的迭代器:vi[10] */

还可以使用关系运算符( < > = >= <= )来比较迭代器的位置, 参与比较的两个迭代器必须合法且指向同一个容器的元素（或者尾元素的下一个位置）

if(it<mid){
    /* 处理vi前半部分的元素 */
    ...
}

两个迭代器相减的结果是两个迭代器的距离 （参与比较的两个迭代器必须合法且指向同一个容器的元素（或者尾元素的下一个位置））

距离值的类型是名为 difference_type 的带符号型整数（可正可负）, string和vector都定义了这个类型。

使用迭代器运算

使用迭代器运算的一个经典算法是二分搜索，二分搜索从某个有序序列中寻找某个给定的值。

    /* text为一个有序序列 */
    string text = {"abcdefghijklmnopqrstuvwxyz"};

    char target = 'y';

    /* beg为迭代器的头， end为迭代器的尾 */
    auto beg = text.begin(), end = text.end();

    /* mid为迭代器的中间位置 */
    auto mid = beg + (end - beg) / 2;

    while (target != *mid && beg != end) {
        cout << target << " vs " << *mid << endl;
        if (target > *mid) {
            beg = mid;
        } else {
            end = mid - 1;
        }
        mid = beg + (end - beg) / 2;
    }

    cout << "rs:" << target << " vs " << *mid << endl;
    return 0;

3.5 数组

数组是一个类似于标准库类型vector的数据结构，但是在性能和灵活性上的权衡与vector不同。

相似的地方：

• 都是存放相同类型对象的容器，这些对象没有名字，通过位置来访问

区别：

• 数组的大小确定不变，不能随意增加元素
• 大部分情况下性能更好，但是灵活性一般

3.5.1 定义和初始化内置数组

数组是一种复合类型（参考2.3节） 数组的声明型如 a[d] , 其中a是数组的名字，d是数组的维度。 维度说明数组中元素的个数，因此必须大于0，编译的时候维度应该是已知的，也就是说维度必须是一个常量表达式。

unsigned cnt = 42;          // 非常量表达式
    constexpr unsigned sz = 42; // 常量表达式，关于constexpr，参见2.4.4节
    int arr[10];    // 含有10个整数的数组
    int *parr[sz];  // 含有42个整型指针的数组
    string bad[cnt] // 错误，cnt非常量表达式
    string bad[getSize()] // 当getSize时constexpr时正确，否则错误

默认情况下，数组的元素被默认初始化（参考2.2.1节）。

和内置类型的变量一样，如果在函数内部定义了某种类型的数组，那么默认初始化会使数组含有未定义的值

定义数组的时候，必须指定确定的类型，不能使用auto关键字。 另外和vector一样，数组的元素必须为对象，所以不存在引用的数组

显示初始化数组的元素 可以对数组进行列表初始化（参考3.3.1节），此时允许忽略数组的维度。

数组初始化时，若没有指定维度，那么编译器会根据初始值的数量推算出数组的维度。 若指定了维度，那么初始值的数量不能超过维度值，可以小于维度值，维度值超过初始值数量的部分将被默认初始化。

    const unsigned sz = 3;
    int intEl[sz] = {0, 1, 2}; // 含有三个元素的数组，元素值分别是0,1,2
    int a2[] = {0, 1, 2};         // 维度是3的数组
    int a3[5] = {0, 1, 2};        // 等价于a3[]={0,1,2,0,0}
    string a4[3] = {"hi", "bye"}; // 等价于a3[]={"hi", "bye",""}
    int a5[2] = {0, 1, 2}; // 错误，初始值超过维度

字符数组的特殊性 字符数组可以使用字符串字面值进行初始化。 字符串字面值在字符串结尾处会有个空字符 \0 ，这个空字符也会被拷贝到数组里面去

    char a1[] = {'c', '+', '+'}; // 列表初始化，没有空字符
    char a2[] = {'c', '+', '+', '\0'}; // 列表初始化，含有显示的空字符
    char a3[] = "c++";  // 使用字符串字面值初始化，自动添加表示字符串结尾的空字符
    char a4[3] = "c++"; // 错误，没有多余的空间可以存放空字符

不允许拷贝和赋值 不能将数组的内容拷贝给其他数组作为其初始值，也不能用数组为其他数组赋值

    int a[] = {0, 1, 2};    // 初始化一个含有3个整数的数组
    int a2[] = a;   // 错误，不允许使用一个数组初始化另一个数组
    a2 = a; // 错误，不能把一个数组直接赋值给另一个数组

某些编译器支持数组的赋值，这就是所谓的编译器扩展 不过一般来说，最好避免使用非标准的特性，以保持代码的可移植性

理解复杂的数组声明 和 vector 一样，数组能存放大多数类型的对象。例如，可以定义一个存放指针的数组，还可以定义对数组的引用及指向数组的指针。

定义存放指针的数组比较简单和直接，定义指向数组的指针或者数组的引用就稍微复杂一些了：

    int * ptrs[10];           // ptrs是含有10个整型指针的数组
    int & refs[10] = /* ? */; // 错误不存在存放引用的数组

    int(*parray)[10] = &arr;   // parray指向一个含有10个整数的数组
    int(&refarray)[10] = arr; // parray引用一个含有10个整数的数组

    int *(&array)[10] = ptrs; // array是数组的引用，该数组含有10个指针

理解数组声明的含义，最好的方法是从数组的名字开始按照由内到外的顺序阅读

3.5.2 访问数组元素

和vector和string一样，数组的元素也能使用范围for语句或者下标运算符号来访问。

数组的索引从0开始，以一个包含10个元素的数组为例，它的索引是从0到9

在使用数组下标时候，通常将他定义为size_t类型。size_t是一种机器相关的无符号类型，它被设计的足够大以便能表示内存中任意对象的大小。

在 cstddef 头文件中定义了 size_t 类型，是c标准库文件 stddef.h 的C++版本

数组除了大小固定这一特点外，其他用法和vector基本类似。 例如可以使用数组来记录各分数段的成绩个数

    /* 统计0-9， 10-20...90-99,100 11个分数段 */
    unsigned scores[11] = {}; // 11个分数段，全部初始化为0
    unsigned grade;
    while (cin >> grade) {
        if (grade <= 100) {
            ++scores[grade / 10];
        }
    }
    cout << endl << "统计中..." << endl;
    
    for(int i : scores){
        cout << i << " ";
    }
    cout << endl;

与3.3.3节中vector的实现相比，一个不太明显的区别是本例子中使用的下标运算是C++语言直接定义的，而vector的下标运算是库模板vector定义的只能用于vector。

与vector和string一样，遍历操作最好使用范围for语句 因为维度是数组类型的一部分，所以数组的唯独是已知的，使用范围for可以减轻认为控制遍历的负担。

检查下标的值 和vector和string一样，数组的下标是否在合理的范围之内由程序员负责检查（下标应该大于等于0且小于数组的大小）。

要想防止下标越界，需要对代码进行细致的检查 c++ lint

3.5.3 指针和数组

在c++语言中，指针和数组有非常密切的联系。比如即将介绍的，使用数组的时候，编译器一般会把它编译为指针。

通常情况下，使用取地址符来获取指向某个对象的指针，取地址符可以用于任何对象。

数组元素也是对象，数组下标可以取到该位置的元素。因此可以使用取地址符取到数组元素的地址。

string nums[]={"one","two","three"};    // 数组的元素是string对象
string *p = &nums[0];       // 指针p 指向数组的第一个元素

通常使用数组类型是使用一个指向数组第一个元素的指针。

所以一些数组的操作，其实是指针的操作。 其中一层意思是，当使用数组作为auto变量的初始值时，推断得到的类型是指针而非数组

int arr[]={0,1,2,3,4,5};    // arr是一个含有6个整数的数组
auto parr(arr);     // parr是一个指针，指向arr的第一个元素
parr=42;    // 错误，parr是一个指针，不能用int值赋给指针

尽管arr是由10个整数构成的数组，但当arr作为初始值时，编译器实际执行到初始化过程类似于下面的形式

auto parr(&arr[0]);     // 显然parr的类型是int *

必须注意的是，当使用decltype关键字时，上述转换不会发生

decltype(arr) arr2 = {0,1,2,3,4}  // arr2是一个有5个元素的数组
int *p;
arr2 = p;   // 错误，不能将整型指针赋值给指针
arr2[3] = 1;    // 正确，将1赋值给arr2的第4个元素

指针也是迭代器 与2.3.2节指针介绍的内容相比，指向数组的指针拥有更多功能。 vector和string的迭代器支持的运算，数组的指针全都支持。 比如，使用递增运算符将指向数组元素的指针移动位置

int arr = {0,1,2,3,4};  // 一个有5个整数元素的数组
int *p = arr;   // p指向arr的第一个元素 a[0]
++p;    // p指向arr的第二个元素 a[1]

和使用迭代器遍历vector一样，使用指针也可以遍历数组

通过数组名字或者数组首元素的地址都能得到指向首元素的指针。 获取尾后指针需要用到数组的一个特殊性质，我们设法获取数组尾元素之后的那个并不存在的元素的地址：

int arr = {0,1,2,3,4};  // 一个有5个整数元素的数组
int *e = &arr[5];   // 指向arr尾元素(第六个元素)的下一个位置的指针

这里使用的下标显然是一个不存在的元素，这个不存在的元素的唯一用处就是提供其地址用于初始化尾指针e，就像尾后迭代器一样，尾后指针也不指向具体的元素。因此不能对尾后指针执行解引用或者递增操作。

用指针重写上面的范围for，目标同样是输出数组中所有元素：

    /* 统计0-9， 10-20...90-99,100 11个分数段 */
    unsigned scores[11] = {}; // 11个分数段，全部初始化为0
    unsigned grade;
    while (cin >> grade) {
        if (grade <= 100) {
            ++scores[grade / 10];
        }
    }
    cout << endl << "统计中..." << endl;

    cout << "范围for:" << endl;
    for (int i : scores) {
        cout << i << " ";
    }

    cout << endl << "指针:" << endl;
    unsigned *pend = &scores[11];       // scores[11]取的是第12个元素
    for (unsigned *pa = &scores[0]; pa != pend; ++pa) {
        cout << *pa << " ";
    }

标准库函数begin和end 尽管可以计算得到数组的尾后指针，但这种用法极容易出错。 为了使指针的使用更简单、安全，C++11新标准引入了两个名为begin和end的函数。

这两个函数与容器中的同名函数成员函数功能类似（3.4.1节）。

int arr[] = {0,1,2,3,4,5,6,7,8,9};  // arr是一个有10个整数的数组
int *beg = begin(arr);  // 指向arr数组首元素的指针
int *last = end(arr);  // 指向arr数组尾元素的下一个位置的指针

begin函数返回指向数组首元素的指针 end函数返回指向数组尾元素的下一个位置的指针 这两个函数定义在 iterator 头文件中。

    cout << "Find the first < 0 element in a array..." << endl << endl;
    int arr[] = {0, 1, 2, 3, 4, -1, -2, -3, -4}; //
    int *abeg = begin(arr), *aend = end(arr);
    int pos = 0;
    while (abeg != aend && *abeg >= 0) {
        ++abeg;
        ++pos;
    }
    if (abeg != aend) {
        cout << "Value:" << *abeg << "，Pos:" << pos << endl;
    }else{
        cout << "Not Found." << endl;
    }    

一个指针如果指向了某种内置类型数组的尾元素的“下一位置”，则其具备与vector的end函数返回的与迭代器类似的功能。特别要注意尾后指针不能执行解引用和递增操作

指针运算 指向数组的指针可以进行指针的所有运算

#include <cstddef>
...
using std::size_t;
constexpr size_t sz = 5;
int arr[sz] = {1,2,3,4,5};
int *p = arr;       // 等价于int *p = &arr[0]
int *p2 = ip + 4;   // ip2指向指针的尾元素arr[4]

给指针加上一个整数，得到的新指针扔需指向同一个数组的其他元素，或者指向同一数组的尾元素的下一个位置。(简单的说，加上的整数后指针位置不能超过元素的最大位置)

int *p = arr + sz;  // p指向arr首元素+5的位置，即尾元素的下一个位置
int *p2 = arr + 10;  // 错误，arr只有5个元素，超出了数组的元素位置，p2为未定义

两个指针相减的结果是它们之间的距离，参与运算的两个指针必须指向同一数组当中的元素：

auto n = end(arr) - begin(arr); // n的值是5,也就是arr中元素的数量

相减的结果类型是一种名为 ptrdiff_t 的标准库类型，和 size_t 一样也是定义在 cstddef 中与机器相关的类型。差值可能为负数，所以 ptrdiff_t 是一种带符号类型。

只要两个指针指向同一个数组的元素，或者尾元素的下一位置，就可以（用关系运算符）进行比较。

int *b = arr, *e = arr + sz;
    /* 位置的比较 */
while(b<e){ 
        // 使用*b
        ++b;
}

如果两个指针分别指向不同的数组，则不可以比较

int i = 0, sz = 42;
int *p = &i, *e = &sz;
/* 未定义的：p和e无关，因此比较毫无意义 */
/* 可能与指针所指变量定义的先后顺序有关，（先定义分配的内存地址较小） */
while(p<e){

}

解引用和指针运算的交互 指针加上一个整数的结果还是指针，如果结果指针还是指向一个元素，允许解引用该结果指针。

int arr[] = {0,1,2,3,4,5};    // 一个6个元素的数组
int last = *(arr + 4);      // 正确，把last初始化为第5五元素，即4

注意圆括号必不可少，不然含义就变了，例如：

int last = *arr + 4;  // 把last初始化为第一个元素加上4的结果值，即0+4=4

下标和指针 如之前所述，在很多情况下使用数组的名字，其实用的是一个指向数组首元素的指针。

典型的例子是，在使用下标操作时，编译器会自动执行上述转换操作。

int arr[] = {0,1,2,3,4,5}; 

int i = arr[2];      // arr转换成指向数组首元素的指针
                    // arr[2]等价于*(arr+2)
int *p = arr;       // p指向arr的首元素
i = *(p+2)          // 等价于*(arr+2),等价于arr[2]

只要指针的结果是指向数组中的元素（或者尾元素的下一个位置），都可以执行下标运算，数组中的下标可以为负数（注意区别标准库中（vector，string等）的下标必须为正，无符号类型）：

int *p = &arr[2];   // p指向索引为2的元素
int j = p[1];       // p[1]等价于*（p+1）,等价于arr[3]
int k = p[-2];      // p[-2]即arr[0]

3.5.4 C风格字符串

尽管C++支持C风格字符串，但在C++程序中最好还是不要使用。因为用起来不太方便，而且极易引发程序漏洞。

C风格字符串不是一种类型，而是为了表达和使用字符串而形成的一种约定俗成的写法：字符串放在数组中并一空字符结束 \0 C标准库string函数

cstring 是C语言头文件 string.h 的C++版本， cstring 提供的一些函数

传入此类函数的指针必须指向以空字符作为结束的数组（而上表所列出的这些函数不负责验证其字符串参数）

char ca[]={'C','+','+'}；   // 没有以空字符结束
cout << strlen(ca) << endl; // 严重错误，ca没有以空字符结束

注意字符 '' 是单引号，C++字符串字面值是 "" 双引号。 上述代码运行不会报错，但是可能会出现错误的结果。 strlen 函数将有可能沿着ca在内存中的位置不断向前寻找，知道遇到空字符才停下来。（如果另一个字符对象的内存位置刚好紧邻ca那就会计算出错误的长度）

比较字符串

TODO 4.1-4.4：

第四章 表达式

4.1 基础

4.1.1 优先级与结合律

组合运算符和运算对象 运算对象转换 重载运算符 左值和右值

4.1.2 优先级与结合律

4.1.3 求值顺序

4.2 算术运算符

布尔值不应该参与运算

溢出和其他算术异常

4.3 逻辑和关系运算符

4.4 赋值运算符

赋值运算符的左侧运算对象必须是一个左值

4.5 递增和递减运算符

除非必须，否则不使用 递增/减运算符的后置版本，性能/编译器优化

4.6 成员访问运算符

a->member 等价于 (*a).member

4.7 条件运算运算符

三元运算符 ? :

4.8 位运算符

4.9 sizeof运算符

sizeof运算符返回一条表达式或一个类型名字所占的字节数。sizeof运算符满足右结合律

sizeof运算的结果取决于其作用的类型

• 对char或者类型为char的表达式，结果为1
• 对引用类型的运算，结果为被引用对象所占空间的大小
• 对指针的运算，结果为指针本身所占空间大小
• 对解引用指针的运算，结果为指针所指向对象所占的空间大小
• 对数组的运算，结果为对数组所有元素的sizeof运算之和。注意sizeof运算不会把数组转换位指针处理。
• 对string或者vector的运算，结果为该类型固定部分的大小，不会计算对象中的元素占用了多少空间(vector是一个class类型，sizeof实际计算的是vector类的大小)

因为sizeof可以返回整个数组的大小，所以可以使用数组的大小除以单个元素得到数组中元素的个数：

constexpr size_t arrsz=  sizeof(a)/sizeof(*a);
int arr[sz];        // 正确，sizeof的返回值是一个常量表达式，参考2.4.4节

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

4.10 逗号运算符

逗号运算符从左向右的顺序依次执行

int count=50;
for(int size=0; size<10 ; ++size,--count){
    ...
}

4.11 类型转换

在C++语言中，某些类型之间存在关联。

如果两种类型存在关联，那么当程序需要其中一种类型的运算对象时，可以用另一种关联类型的对象或者值来替代。 即，如果两种类型可以相互转换，那么它们就是关联的

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

C++语言不会直接将两个不同类型的值相加，而是先根据类型转换规则将对象的类型统一后再求值。（这种转换是自动进行的，被称为隐式转换）

算术类型之间的转换被设计的尽可能避免损失精度。比如表达式中既有整型又有浮点型的运算对象，整型会转换为浮点型再相加。

相加完成后是将结果初始化给左面的对象ival，由于被初始化的对象类型不可以改变，所以初始值被转换成该对象的类型。

何时发生隐式类型转换

• 在大多数表达式中，比int类型小的整型值首先提升为较大的整数类型
• 在条件中，非布尔值转换成布尔值
• 初始化过程中，初始值转换成变量的类型；在赋值语句中，右侧运算对象转换成左侧运算对象的类型
• 如果算术运算或者关系运算的对象有多种类型，需要转换成同一种类型
• 如第六章介绍的，函数调用时也会发生类型转换

4.11.1 算术转换

算术转换的含义是把一种算术类型转换成另一种算术类型

其中运算符的运算对象将转换成最宽的类型。如一个运算对象的类型是long double，哪么其他的运算对象不管是什么类型都会转换为long double（因为long double已经是C++中最宽的类型了） 整型提升

bool 
char
signed char
unsigned char 
short
unsigned short等类型

只要它们的值可能会存于int内，那么就会提升为int类型，否则提升为unsigned int类型。 比如布尔值false提升为0，true提升为1。

较大的char类型

wchar_t
char16_t
char32_t

提升成

int
unsigned int
long 
unsigned long
long long 
unsigned long long

中最小的一种，前提是： 转换后的类型一定要能容纳原类型所有可能的值

无符号类型的运算对象 如果某个运算符的运算对象类型不一致，这些运算对象将转换成同一类型。

但是如果某个运算对象的类型是无符号类型，那么转换结果就依赖于机器中各个整数类型的相对大小了。（相对大小指的是，无符号类型超过其范围时候又从 0开始，|大小|-类型大小）

• 无符号类型 > 带符号类型，带符号类型转换为无符号类型

即如果int类型为负值的时候，将以2.1.2节的方式转换，并带有该节所介绍的副作用

• 无符号类型 < 带符号类型, 此时的转换依赖与机器。如果无符号类型的所有值都可以存在带符号类型中，则无符号类型转成带符号类型。如果不能，则带符号类型转成无符号类型。

理解算术转换

bool flag;
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是false，否则flag是true
cval + fval;  // cval提升成int，然后该int值转换成float
ival + ulval;  // ival转换成usigned long
usval + ival;  // 根据unsigned short 和int所占空间大小进行提升
uival + lval;  // 根据unsigned int 和 long 所占空间大小进行提升

4.11.2 其他类型隐式转换

数组转换成指针：在大多数用到数组的表达式中，数组自动转换成指向数组元素的指针

int ia[10];     // 含有10个整数的数组
int *ip = ia;   // ia转换成指向数组首元素的指针

• 当数组被用作decltype关键字的参数，或者作为取地址符 & 、sizeof、及typeid(第19.2.2节介绍)等运算符的运算对象时，上述转换不会发生。
• 如果用一个引用来初始化数组，上述转换也不会发生
• 在6.7节将看到，当表达式中使用函数类型时会发生类似的指针转换

指针的转换：C++还规定了几种其它的指针转换方式

• 常量整数值0或者字面值nullptr能转换成任意指针类型
• 指向任意非常量的指针能转换成void*
• 指向任意对象的指针能转换成const void*
• 15.2.2节将介绍，在有继承关系的类型间还有另一种指针的转换方式

转换成布尔类型：

• 如果指针或者算术类型的值为0, 转换的结果是false，否则为true

转换成常量：允许将指向非常量的指针转换成指向相应的常量类型的指针，引用类型也是这样。

• 如果T是一种类型，我们就可以将指向T的指针或引用分别转换成指向const T的指针或者引用（2.4.1节，2.4.2节）

int i;
const int &j = i;   // 允许非const int转换成const &int的引用
const int *p = &i;   // 允许非const int转换成const &int的指针
int &r = j, *q = p;  // 错误，不允许底层const转换成非const

类类型定义的转换：类类型能定义由编译器自动执行的转换，不过编译器每次只能执行一种类类型的转换。在7.5.4节中我们将看到一个例子，如果同时提出多个转换请求，这些请求将被拒绝。

我们之前已经使用过标准库类型string的定义的转换：

string s, t = "a value";    // 字符串字面值转换成string类型
while( cin >> s)    // while的条件部分把cin转换成布尔值

4.11.3 显式转换

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

int i=3, j=2;
double slope = i / j;   // 如果不做强制类型转换
                        // 结果将会是3/2=1.5取整为1,
                        // 再初始化转为double类型1.00给slope
                        // 而我们的期望值是1.50

这时就需要将 i 、 j 显示地转换成double，这种方法称作强制类型转换 cast

虽然有时不得不使用强制类型转换，但这种方法本质上是非常危险的

命名的强制类型转换 一个命名的强制类型转换有如下形式：

cast-name<type> (expression);

其中type是转换的目标类型而expression是要转换的值。 如果type是引用类型，则结果是左值 cast-name 有： static_cast 、 dynamic_cast 、 const_cast 和 reinterpret_cast dynamic_cast 支持运行时类型识别，我们将在19.2节做更详细的介绍

static_cast 任何具有明确定义的类型转换，只要不包含底层const，都可以使用static_cast。

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

当需要把一个较大的算术类型赋值给较小的类型时，static_cast非常有用。此时，强制类型转换告诉程序的读者和编译器：我们知道并且不在乎潜在的精度损失。

一般来说，如果编译器发现一个较大的类型试图赋值给较小的类型，就会给出警告信息。现在我们执行了显示的类型转换后，警告信息就会被关闭了。

static_cast对于编译器无法自动执行的类型转换也非常有用。 例如我们可以使static_cast找回存在于void*的指针中的值（参见2.3.2节）：

// d是一个double类型
void *p = &d;   // 正确，任何非常量对象的地址都可以存入void*
double *dp = static_cast<double *>(p); // 正确，将void*转换为正确的指针类型

强制转换指针类型时，应该与指针的原类型一致，否则会出现未定义的结果。

const_cast const_cast将常量对象转换为非常量对象，即去除const。 const_cast只能改变对象的底层const

如果对象本身不是常量，使用const_cast转换后可以获得写的权限 如果对象本身是常量，使用const_cast执行写的操作就会产生未定义的结果

const char *pc;
char *pc = const_cast<char *>(pc); // 正确；但是通过p写值会产生未定义的结果

只有 const_cast 能改变表达式的常量属性，使用其他形式的转换都将引发编译器错误。

而使用 const_cast 也不能改变数据类型。

reinerpret_cast 使用reinerpret_cast非常危险，对类型的上帝操作

旧式的强制类型转换

在早期的C++版本中，显式的进行强制类型转换包含两种形式：

type (expr);    // 函数形式的强制类型转换
(type) expr;    // C语言风格的强制类型转换

根据所涉及的类型不同，旧式的强制类型转换分别具有与const_cast、static_cast或者reinerpret_cast相似的功能

char *pc = (char*) ip;  // ip是指向整数的指针

与命名的强制类型转换相比，旧式的强制类型转换从表现形式上不那么清晰明了，容易被看漏，所以一旦转换过程出现问题，追踪起来也更加困难。

4.12 运算符优先级表

TODO: 5.1-5.3:

第五章 语句

5.1 简单语句

5.2 语句作用域

C++中大多数语句都以分号结束，一个表达式，（比如ival+5）,末尾加上分号，就变成了表达式语句，表达式语句的作用是执行表达式并丢弃掉求值结果。

ival + 5;   // 一条没有什么作用的表达式语句
cout << ival;   // 一条有用的表达式语句

// 第一条语句没有什么用处，虽然执行了加法，但是相加的结果没有被使用。

// 比较普遍的情况是，表达式中的表达式在求值时附带有其他效果
// 比如变量赋了新值或者输出了结果

空语句

; // 一个空语句

// 重复读入数据，直至文件末尾或某次输入的值等于sought
while(cin >> s && s != sought)
    ; // 空语句

别漏写分号，也别多写分号 复合语句（块） 复合语句是指用花括号括起来的（可能为空的）语句和声明的序列。 复合语句也被称为块，一个块就是一个作用域（参见2.2.4节 43页）

while(val <=10){
    // 作用域
}

{
    // 新的作用域

}
{}  // 空块

• “块级作用域”，if、switch、while和for语句的控制结构内定义的变量，作用域只在结构内部

5.3 条件语句

5.3.1 if语句

5.3.2 switch语句

case必须是常量表达式（2.4.4节）

5.4 迭代语句

5.4.1 while语句

while(condition){
    statement;
}

5.4.2 传统的for语句

initializer可以是声明语句、表达式或者空语句

for(initializer;condition;expression){
    statement
}

• 1循环开始时执行initializer
• 2接下来判断condition，true执行循环体，false循环终止
• 3循环体执行完，执行expression
• 循环2-3直到终止

5.4.3 范围for语句

for(declaration: expression){
    statement
}

expression必须是一个序列，比如{1, 2, 3}, string或者vector declaration要执行写操作，必须为引用类型

vector<int> v={1,2,3};

// r只能进行读操作
for(auto r: v){
    statement
}

// r可以进行读写操作
for(auto &r: v){
    statement
}

5.4.4 do while语句

do while语句和while十分类似，区别是不管条件是否为真，都会至少执行一次循环

do{
    statement
}    
while (condition);

注意while后需要有个分号

condition使用的变量不能定义在do循环体内

5.5 跳转语句

break, continue, goto, return

5.5.1 break 语句

break负责终止离它最近的一个while, do while, for或者switch 只能出现在这些语句的结构内部

5.5.2 continue 语句

break负责终止离它最近的一个循环并立即开始下一次循环

5.5.3 goto 语句

goto语句的作用是从goto语句无条件跳转到同一函数的另一条语句

goto label;

label: xxxx;

不要在程序中使用goto，因为它使得程序既难理解又难修改

5.6 try 语句块和异常处理

• throw 表达式： 抛出异常
• try catch 语句块： try尝试捕获异常 catch处理异常
• 异常类，用于在throw表达式和相关的catch字句之间传递异常的具体信息

5.6.1 throw 表达式

if(...){
    throw runtime_error("xxxxxxxx is wrong");
}

runtime_error 是标准异常类型的一种，定义在 stdexcept 头文件中。 更多标准异常类型在5.6.3节介绍。

5.6.2 try 语句块

try{
    program-statements
} catch( exception-declaration ){
    program-statements
} catch( exception-declaration ){
    program-statements
}

• 同样拥有块级作用域，特别是try语句块里面的声明，在catch里面也无法访问

try{
    // 异常时抛出一个runtime_error
    throw runtime_error("xxxxxxxx is wrong");
} catch( runtime_error &err ){
    cout << err.what() << "ERROR!" << endl;
}

如果一段程序没有try语句且发生了异常，系统会调用terminate函数并终止当前程序的执行

5.6.3 标准异常

• exception头文件定义了最通用的异常类exception。它只报告异常的发生，不提供任何额外信息
• stdexcept头文件定义了几种常用异常类，见下图
• new头文件定义了bad_alloc异常类型，这种类型在12.1.2节介绍
• type_info头文件定义了bad_cast异常类型，这种类型在19.2节介绍

exception、bad_alloc、bad_cast 异常类型只能默认初始化（括号加字符串字面值），不能被赋与值

try{
    // 异常时抛出一个runtime_error
    throw runtime_error("xxxxxxxx is wrong");
} catch( runtime_error &err ){  
    
    // 取runtime_error的引用,原因参考https://stackoverflow.com/questions/6755991/catching-stdexception-by-reference

    cout << err.what() << " ERROR!" << endl;
    // xxxxxxxx is wrong ERROR!
}

异常类型只有一个成员函数 what() ，返回一个指向c风格字符串的const char*, 提供关于异常的文本信息

第六章 函数

函数的定义、声明，传入参数、返回结果 重载函数 函数指针

6.1 函数基础

编写函数 函数的组成

• 返回类型 return type
• 函数名
• 参数列表: 0个或者多个形参，以逗号隔开
• 函数体

int funcName(int a, int &b){
    return a+(b++);
}

调用函数 函数的调用

• 调用运算符来执行函数： funcName() ,
• 括号内传入调用函数实际使用的参数，即实参。 funcName(a,b)
• 返回类型即函数定义的返回类型, int b=2; int rs = funcName(1,b);

函数的调用完成两项工作：1是用实参初始化函数对应的形参，隐式的定义并初始化它的形参。2是将控制权转移给被调用函数，此时主调用函数的执行被暂时中断，被调函数开始执行。

当遇到return时结束函数的调用，return语句也完成两个工作：1是返回return语句中的值（如果有的话）。2是将控制权从被调用函数转移回主调函数

形参和实参 C++中规定，形参和实参数量应该一致，所以函数定义了多少个参数，调用时候就必须传多少个参数（除非函数重载）

函数的形参列表

void f1(){}     // 隐式地定义空形参列表
void f2(void){}  // 显式地定义空形参列表

/* 必须为每个形参单独指定类型 */
void f2(int v1, v2){}  // 错误
void f2(int v1, int v2){}  // 正确

• 必须为每个形参单独指定类型
• 任意两个形参不能同名
• 外层作用域的变量不能和形参同名

函数返回类型 大多数类型都可以作为函数返回类型。 一种特殊的返回类型是void，表示函数不返回任何值。

函数的返回类型不能是数组类型或者函数类型，但是可以是指向数组或者函数的指针。

6.3.3介绍如何定义一种特殊的函数，它的返回值是指向数组的指针 6.7介绍如何返回指向函数的指针

6.1.1 局部对象

在C++中，名字有作用域，对象有生命周期，理解这两个概念非常重要

• 名字的作用域是程序文本的一部分，名字在其中可见
• 对象的生命周期是程序执行过程中该对象存在的一段时间

函数体是一个语句块。块构成一个新的作用域，我们可以在其中定义变量。

形参和函数体内部定义的变量统称为局部变量，它们对函数而言是局部的，仅在函数的作用域内可见（可用），对外部隐藏。

局部变量的生命周期依赖于定义的方式（见下方）

自动对象 普通声明的变量，在块作用域中执行时候被初始化，块执行完后销毁。 比如函数的形参、for循环的initializer

#include<iostream> 
using namespace std; 
  
// A function with default arguments, it can be called with  
// 2 arguments or 3 arguments or 4 arguments. 
int sum(int x, int y, int z=0, int w=0) 
{ 
    return (x + y + z + w); 
} 
  
/* Driver program to test above function*/
int main() 
{ 
    cout << sum(10, 15) << endl; 
    cout << sum(10, 15, 25) << endl; 
    cout << sum(10, 15, 25, 30) << endl; 
    return 0; 
}

内置类型的未初始化局部变量的值将无法预测

局部静态对象 局部静态对象只在第一次执行该语句时初始化，并且直到程序终止才被销毁

下面的函数统计它被调用了多少次：

size_t callCount() {
    static size_t cnt = 0;
    return ++cnt;
}

int main() {
    using std::cin;
    using std::cout;
    using std::endl;

    callCount();
    callCount();
    size_t cnt = callCount();
    cout << "cnt:" << cnt << endl;
    return 0;
}

6.1.2 函数声明

函数必须在使用前声明。

函数声明也叫函数原型。

函数声明可以省略函数体

函数声明可以省略形参名 void funcName(int, int&, string, double, int*);

/* 函数声明 */
void funcName(int a);
void funcName(int a);

/* 函数定义 */
void funcName(int a){
    return a;
}

• 函数可以声明多次，但只能定义一次
• 如果函数不使用的话，可以只有声明，没有定义。

在头文件中进行函数声明 我们之前建议变量在头文件中声明（2.6.3节），在源文件中定义。函数也应该如此。

将函数声明放在头文件中，可以确保同一函数的所有声明保持一致。而且如果我们想要改变函数的接口，只需改变一条声明即可。

定义函数的源文件应该把含有函数声明的头文件包含进来，编译器负责验证函数的定义和声明是否匹配。

含有函数声明的头文件应该被包含到定义函数的源文件中

6.1.3 分离式编译

C++支持分离式编译，允许我们把程序分隔到几个文件中去，每个文件单独编译。

• 源文件 .cpp
• 头文件 .h

编译和链接多个源文件 我们有个 compute 函数，声明在 compute.h 中，定义在 compute.cpp 中并引用头文件 compute.h 主函数 main 在 main.cpp 中， main 函数中将调用 compute 函数。

define C++ functions inside header files?

• 头文件 compute.h

  #ifndef FUNCTIONS_H_INCLUDED
  #define FUNCTIONS_H_INCLUDED
  // 函数定义（函数原型）
  int add(int a, int b);  
  #endif

• 功能函数 compute.cpp

  #include "compute.h"
  // 函数声明
  int add(int a, int b){
      return a + b;
  }

• 主函数 main.cpp

  #include <iostream>
  #include "compute.h"
  // 程序入口
  int main()
  {
      std::cout << "add(1, 2) = " << add(1, 2) << '\n';
  }

要生成可执行文件，必须告诉编译器我们用到的代码在哪里:

g++ main.cpp compute.cpp
g++ main.cpp compute.cpp -o main

6.2 参数传递

如之前所述，每次调用函数都会重新创建它的形参，并用传入的实参对形参进行初始化

形参的初始化和变量的初始化一样

形参的类型决定了形参和实参交互的方式：

• 如果形参是引用类型，它将绑定到对应的实参上， 引用传递，传址
• 否则，将实参的值拷贝后赋给形参， 值传递，传值

6.2.1 传值参数

非引用传参，实参的值拷贝给形参，修改形参不会对实参产生影响。

指针形参 指针的行为和其他非引用类型是一样，不过拷贝的是指针的值，而非指针指向对象的值。

拷贝后，实参和形参的指针是两个不同的指针，但都指向同一个对象，所以可以解引用来操作所指的对象。

int funcName(int *p2){
    *p2=0;           // 将a的值改变为0
    p2=0             // 将形参p2指向0，不会影响实参p仍指向a
}

int a=1;
int *p = &a;

funcName(p);
// funcName(&a);

// 相当于
/* 
    int a=1;
    int *p = &a;

    // 初始化形参
    int *p2 = p;
    *p2=0;
    p2=0
 */

6.2.2 传引用参数

/* 接收一个对int对象的引用*/
int funcName(int &r2){
    r2=0;           // 将a的值改变为0                 
}

int a=1;
funcName(a);

// 相当于
/* 
    int a=1;    

    // 初始化形参
    int &r = a;
    r=0;
 */

使用引用避免拷贝 拷贝大的类型对象或者容器对象比较低效，甚至有些类类型不支持拷贝操作（比如IO类型）

避免拷贝传入的参数，直接使用引用类型定义形参。

如比较两个（比较长的）字符串：

bool isStrShorter(string &str1,string &str2){
    
}

使用引用形参返回额外信息 在原有函数上增加功能时，可以考虑使用形参多传一些参数来记录额外的信息

6.2.3 const形参和实参

当形参是const时，必须要注意2.4.3节关于顶层const的讨论。

和其他初始化一样，用实参初始化形参时会忽略掉顶层const（即形参的顶层const被忽略，形参有顶层const时，可以传常量也可以传非常量）

void fcn(const int i){  /* i可以传常量，也可以传非常量 */

    /* 函数体内i只读，不可写 */

}     

void fcn(const int i){}     
void fcn(int i){}     /* 错误，重复定义了fcn(int) */

C++中可以定义多个同名的函数，前提是参数不同。 上面的例子由于顶层const被忽略，所以参数是一样的，因此报错。

指针或引用形参 与const

尽量使用常量引用 在不会改变引用形参的函数中，尽量使用常量引用

6.2.4 数组形参

数组的两个性质：1不允许拷贝数组 2使用数组时（通常）会将其转换为指针

当我们为函数传递一个数组时，实际上传递的是指针数组首元素的指针

/* 
    尽管形式不同，三个print是等价的
    每个函数都是const int*的形参（数组转换为指针）
*/
void print(const int*){}
void print(const int[]){}
void print(const int[10]){}     // 这里维度没有作用

因为数组是以指针的形式传递给函数的，所以函数不知道数组的确切尺寸。 有三种常用的方式：

使用标记指定数组长度 C风格字符串，以 \0 结尾

使用标准库规范 传入begin和end的指针

void print(int *beg, int *end){
    while(begin != end){
        /* statement */
    }
}

显示传递一个表示数组大小的形参

void print(const int ia[],size_t size){

}

数组形参和const 6.2.3的讨论同样适用

数组引用形参 C++允许将变量定义成数组的引用3.5.1，同样的形参也可以是数组的引用。此时，引用形参绑定到对应的实参上，也就是绑定到数组上。

/* 形参是数组的引用，维度是类型的一部分 */
void print(int (&arr)[10]){

}

void print(int &arr[10])   // 错误，声明为了元素类型为引用的数组

传递多维数组

C++中没有真正的多维数组，所谓的多维数组是数组的数组

当将多维数组传递给函数时，真正传递的是指向数组首元素的指针。 因为我们处理的是数组的数组，所以首元素本身就是一个数组，指针就是一个指向数组的指针。数组的第二维（及后面所有维度）的大小都是数组类型的一部分，不能省略

// matrix指向数组的首元素该数组的元素是由10个整数构成的数组
void print(int (*matrix)[10], int rowSize){}

matrix两端的括号必不可少, int (*matrix)[10] 否则就是元素类型为指针的数组

6.2.5 main处理命令行选项

我们之前定义的main函数都只有空形参列表，main函数也可以传递参数的。

一种常见的情况是通过设置一组选项来确定函数要执行的操作。 例如：

/* 假定main函数位于可执行文件prod之内 */
prod -d -o outfile data0

/* 这些命令行选项通过两个（可选的）形参传递给main函数 */
int main(int argc, char *argv[]){
}

• 第二个参数argv是一个数组，它的元素是指向c风格字符串的指针，表示命令行命令的字符串
• 第一个参数argc表示数组中字符串的数量
• 当实餐传给main函数之后，argv的第一个元素指向程序名字或者一个空字符串，后面的参数依次传递命令行的参数，命令最后一个指针元素的值保证为0

prod -d -o outfile data0

/* 
    argc为5
    argv[0] = "prod";       // 或者argv[0]也可以指向一个空字符串
    argv[0] = "-d";
    argv[0] = "-o";
    argv[0] = "ofile";
    argv[0] = "data0";
    argv[0] = 0;
*/

当使用argv时候，一定要记住从argv[1]开始。argv[0]保存的是程序的名字，而非（用户输入）命令参数

6.2.6 含有可变形参的函数

有时我们无法提前预知应该向函数传递几个实参。

C++11提供两种主要的方式处理不同数量的函数参数

• 如果所有参数的类型相同，可以传递一个initializer_list的标准库类型。
• 如果参数类型不相同， 可以编写可变参数模板，在16.4节介绍
• 还有一种特殊的形参类型（即省略符），可以用它传递可变数量的实参，不过这个用法一般只用于与C函数交互的接口程序

initializer_list形参 initializer_list是一种标准库类型，用于表示某种特定类型的值的数组

• initializer_list和vector一样也是一种模板类型
• 区别是initializer_list中的元素永远是常量值，无法操作initializer_list的元素
• 有成员函数 begin end
• 调用时使用花括号 {}
• 含有initializer_list的函数也可以同时拥有其他形参

void printError(initializer_list<string> err, ErrCode e){
    for(
        auto beg = err.begin();
        err.begin() != err.end();
        ++beg
    ){
        cout << *beg <<　endl;
    }    
    cout << endl;
}

string s = "error";
string s2 = " !";
printError({“here is a ”, s , s2}, ErrCode(0))

省略符形参 省略符形参是为了便于C++程序访问某些特殊的C代码而设置的，这些代码使用了名为varargs的C标准库功能。

通常省略符形参不应用于其他目的。你的C编译器文档会描述如何使用varargs。

省略符形参应该仅仅用于C和C++通用的类型。特别注意的是，大多数类类型的对象在传递给省略符形参时都无法正确拷贝

省略符形参只能出现在形参列表的最后一个位置，它的形式无外乎一下两种：

void foo(params,params2,...);
void foo(...);

6.3 返回类型和return语句

return语句终止当前正在执行的函数并将控制权返回到调用该函数的地方： return语句有两种形式：

return ;
return expression;

6.3.1 无返回值函数

没有返回值的函数只能用在 void 类型的函数中。 也可以省略return，因为此类函数最后一句后面会隐式的执行return

函数中间位置提前退出也可以用return

void函数中也可以使用 return expression; 的形式，不过表达式的值需要时void

void函数return了其他类型会产生编译错误。

6.3.2 有返回值的函数

只要函数不是void，则每条return语句必须返回一个值。 return的类型必须和函数类型一致，或者能隐式转换为函数类型。

编译器会判断return结果类型的正确性

在含有return语句的循环后面也应该有一条return语句，如果没有的话该程序就是错误的。很多编译器都无法发现此类错误。

值是如何被返回的 返回一个值得方式和初始化一个变量或形参的方式完全一样：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果。

string parseString(size_t sSize,const string &word,const string &ending){
    return (sSize>1) ? word + ending : word;
}

判断数值大于1, 返回单词的复数形式，否则返回单数形式。 由于返回类型为string，（非指针或者引用）所以意味着返回值将拷贝到 调用点 是返回值的一个副本

如果函数返回类型为引用，则不会进行拷贝操作，返回的引用是它所引对象的一个别名：

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

其中形参和返回类型都是const string的引用，所以不管是调用函数还是返回函数都不会真正拷贝string对象。

不要返回局部对象的引用或指针 函数执行完后，它所占用的内存空间也随之被释放掉。因此函数内部定义的变量将不会在内存当中（局部变量的引用将指向不再有效的内存区域）

const string &manip(){
    string ret;
    // 
    if(!ret.empty()){
        return ret;         // 错误：返回局部对象的引用
    }else{  
        return "empty"      // 错误：“empty”是一个局部临时量
    }
}

字符串字面值会转换成一个局部临时string对象。 对于上面的函数来说，“empty”和ret都是局部的。当函数结束的时候，临时对象占用的空间就随之释放掉了，所以两条return语句都指向了不再可用的内存空间。

要确保返回值的安全，看看return的值到底是不是局部的

指针也是同样的，将函数内定义的局部的指针return的也是错误的。函数执行完成，局部的指针将指向不存在的对象。

返回类类型的函数和调用运算符 调用运算符号的优先级与点运算符和箭头运算符相同，并且也符合左结合律。 所以如果函数返回指针、引用或类的对象，我们就可以使用函数调用的结果访问其成员。

string &shorterString(const string &s1, const string &s2);

auto ss = shorterString("123", "1234").size(); // ss=4

引用返回左值 返回值是引用类型的函数得到左值，其他返回类型得到右值

返回类型是非常量引用类型时，可以操作返回结果引用的对象（常量引用类型时，不可以可以操作返回结果引用的对象）

char &getVal(string &str, string::size_type idx) {
    return str[idx]; // getVal假定idx是有效的
}

getVal("hello",0)='i';  // iello

列表初始化返回值 C++11标准规定，函数可以返回花括号包围的值得列表。

若列表为空，则进行默认初始化 返回值类型由函数类型决定

vector<string> process(){
    if(expected.empty()){
        return {}       // 返回一个空的vector对象
    }else if(expected== actual){
        return {"functionX", "Okay"};  // 返回列表初始化的vector
    }else{
        return {"functionX", expected, actual }; // 返回列表初始化的vector
    }
}

如果函数返回类型是内置类型，则花括号包围的列表最多包含一个值，且所占空间不应该大于目标类型的空间。

如果返回的是类类型，则由类来定义初始值如何使用。

主函数main的返回值

主函数main允许没有return，编译器会隐式地插入一条return 0

递归

函数直接或者间接调用本身

int factorial(int val){
    if(val > 1){
        return factorial(val-1) * val;
    }
    retutn 1;
}

6.3.3 返回数组指针

因为数组不能拷贝，所以函数不能返回数组。

不过函数可以返回数组的指针或者引用。

一个返回数组的指针或者引用的定义比较繁琐，有一些方法可以简化这些定义：

使用类型别名：

typedef int arrT[10];

using arrT = int[10];

/* 上面两种定义等价，arrT是一个类型别名，它表示的类型是含有10个整数的数组 */

arrT* func(int i);  // func返回一个指向含有10个整数的指针

声明一个返回数组指针的函数 不实用类型别名的话，声明一个返回数组指针的函数：

int (*func(int i))[10];

可以按照一下顺序来逐层理解该声明的含义：

• func(int i) 表示调用func需要一个int类型的实参
• (*func(int i)) 意味着我们可以对函数调用的结果执行解引用操作
• (*func(int i))[10] 表示解引用操作得到一个大小是10的数组
• int (*func(int i))[10] 表示数组中元素类型是int

使用尾置返回类型

auto func(int i) -> int(*)[10];

使用decltype

如果知道函数返回的指针指向哪个数组，就可以使用decltype

int odd[] = {1,3,5,7,9};
int even[] = {2,4,6,8,10};

decltype(odd) *arrPtr(int i){
    return (i % 2) ? &odd : &even;
}

注意decltype不会将数组名转换成指针，需要在函数声明处添加一个*表示函数返回的是一个指针。

6.4 函数重载

在同一个作用域的几个形参列表不同的同名函数，称为重载函数（overloaded）

在6.2.4中我们定义了几个名为print的函数：

void print(const char * cp);
void print(const int *beg, const int *end);
void print(const int ia[], size_t size);

调用函数时，编译器会根据传递的实参个数、类型推断调用的哪个函数

int j[2] = {0,1};
print("Hello world");       // 调用print(const char * cp);
print(j, end(j)-begin(j));  // 调用print(const int ia[], size_t size);
print(begin(j), end(j));    // 调用print(const int *beg, const int *end);

main函数不能重载

定义重载函数

有一种典型的数据库应用，创建一个函数分别根据名字、电话、账户号码等信息查找记录。

/* Record、Account、Phone、Name 为自定义的数据类型，或者别名 */

Record lookup (const Account&); // 根据Account查找记录
Record lookup (const Phone&);   // 根据Phone查找记录
Record lookup (const Name&);    // 根据Name查找记录

Account act;
Phone phone;
Record r1 = lookup(act);    // 调用lookup (const Account&);
Record r1 = lookup(phone);  // 调用lookup (const Phone&);

重载函数的形参应该是：数量不同或者数据类型不同，否则编译错误：二义性调用

判断两个形参是否相异

有时两个形参看起来不一样，但实际上是相同的。

Record lookup(const Account& acct);
Record lookup(const Account& ); // 省略形参的名字

typedef Phone Telno;
Record lookup(const Phone& ); 
Record lookup(const Telno& ); // Phone和Telno类型相同

重载和const形参 如6.2.3介绍的，顶层const(2.4.3节)不影响传入函数的对象。

有顶层const的形参和同类型的无顶层const的形参无法用于区分函数重载

Record lookup(Phone);
Record lookup(const Phone);  // 顶层const被忽略，重复声明了Record lookup

Record lookup(Phone*);
Record lookup(Phone* const);  // 指针的顶层const,重复声明了Record lookup

指针

• Phone* const 顶层const 指针本身是常量
• const Phone* 底层const 指向常量的指针

引用

• Phone& const 顶层const 引用本身是常量
• const Phone& 底层const 引用了常量的引用

Record lookup(Phone&);
Record lookup(const Phone&);  // 底层const，未重复，函数为lookup的另个一重载

Record lookup(Phone*);
Record lookup(const Phone*);  // 底层const，未重复，函数为lookup的另个一重载

调用时，只能const实参只能调用const形参。

相反的，因为非常量可以转换为const，所以上面四个函数都可以作用于非常量对象，或者指向非常量对象的指针。而编译器会优先选用非常量的版本。

合理使用函数重载，功能差异大的函数还是使用不同的函数名可读性更好

void move(int, int); void moveAbs(int, int); void slide(int, int);

const_cast和重载

在4.11.3节中我们说过，const_cast在重载函数的情景中最有用。

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

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的引用，然后调用了shorterString函数的const版本。const版本返回对const string的引用，这个引用事实上绑定在某个初始的非常量实参上。因此我们可以再将其转换回一个普通的string&，这显然是安全的
*/

调用重载的函数 定义了一组重载函数后，我们需要以合理的实参调用它们。调用时候进行函数匹配/重载确定，编译器首先将调用的实参与重载集合中每一个函数的形参进行比较，然后根据比较的结果决定到底调用哪个函数。

调用重载函数有三种可能的结果：

• 编译器找到一个与实参最佳匹配的函数，并生成调用该函数的代码。
• 找不到任何一个函数与调用的实参匹配，编译器发出无匹配的错误
• 有多于一个函数可以匹配，但是每一个都不是明显的最佳选择。此时编译器发出二义性调用的错误

6.4.1 重载与作用域

重载对作用域的一般性质没有什么改变：

• 在内层作用域中声明的名字，它将隐藏外层作用域中声明的同名实体。
• 在不同的作用域中无法重载函数名

string read();

void print(const string &);
void print(double);     // 重载print函数

void fooBar(int ival){
    bool read = false;  // 新作用域：隐藏了外层的read
    string s = read();  // 错误，read是一个布尔值，不是一个函数

    /* 
        不好的习惯：通常来说，在局部作用域中声明函数是不好的
    */
    void print(int);    // 新作用域，隐藏了之前的所有print

    print("Value: ");    // 错误，print(const string &)被隐藏掉了
    print(1);            // 正确，当前print(int)可见
    print(3.14);         // 正确，调用的是print(int)，实参的double隐式转换为int，print(double)被隐藏掉了
}

在调用print函数时，编译器首先寻找对该函数名的声明，找到的是接受int值的那个局部声明。一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体。剩下的工作就是检查函数调用是否有效了。

在C++中名字查找发生在类型检查之前

TODO： 6.5-6.7

6.5 特殊用途语言特性

默认实参、内联函数、constexpr函数及在调试过程中常用的一些功能

6.5.1 默认实参

使用默认实参调用函数

默认实参声明 默认实参初始值

6.5.2 内联函数和constexpr函数

内联函数可以避免函数调用的开销 constexpr函数 把内联函数和constexpr函数放在头文件内

6.5.2 调试帮助

assert预处理宏 NDEBUG预处理变量

6.6 函数匹配

确定候选函数和可行函数 寻找最佳匹配 含有多个形参的函数匹配

6.6.1 实参类型转换

需要类型提升和算术类型转换的匹配 函数匹配和const实参

6.7 函数指针

声明一个指向函数的指针，只需用指针替换函数名即可：

/* 
    pf指向一个函数，该函数的参数是两个const string的引用，
    返回值是bool类型
 */
bool (*pf)(const string &, const string &)

使用函数指针 使用函数时，函数名会自动转换成指针。

函数指针可以赋值给另一个指针（前提是函数的形参类型和返回类型需要与被赋值的指针的数据类型一直）。

重载函数的指针 当使用指针指向重载函数时，上下文必须清晰地界定到底应该选用哪个函数。编译器根据指针类型决定选用哪个函数，指针类型必须与重载函数中的某一个精确匹配。

void ff(int *);
void ff(unsigned int);

void (*pf)(unsigned int) = ff;  // pf指向ff(unsigned int)

void (*pf2)(int) = ff;  // 错误，形参列表不匹配，没有任何一个ff与该形参列表匹配

double (*pf3)(int *) = ff // 错误，返回类型不匹配

函数指针（作为）形参 和数组类似（参见6.2.4节），虽然不能定义函数类型的形参，但是形参可以是指向函数的指针。

void useBigger(
    const string &s1, 
    const string &s2,
    bool pf(const string &, const string &));

/* 函数作为形参将自动转换成指针，也可以显式地定义函数的指针，这两种声明是等价的 */
void useBigger(
    const string &s1, 
    const string &s2,
    bool (*pf)(const string &, const string &));

/* 
    调用时候也是可以直接使用函数名，它将自动转换成指向该函数的指针
 */

useBigger(s1,s2,lengthCompare);

类型别名和decltype可以让我们简化使用函数指针的代码。

bool lengthCompare(const string &, const string &);

/* 这两种声明等价, Func和Func2是函数类型 */
typedef bool Func(const string &, const string &);
typedef decltype(lengthCompare) Func2;

/* 这两种声明等价, FuncP和FuncP2是指向函数的指针类型 */
typedef bool (*FuncP)(const string &, const string &);
typedef decltype(lengthCompare) FuncP2;

/* 等价的声明 */
void useBigger(
    const string &s1, 
    const string &s2,
    Func)
void useBigger(
    const string &s1, 
    const string &s2,
    Func2)
void useBigger(
    const string &s1, 
    const string &s2,
    FunP)
void useBigger(
    const string &s1, 
    const string &s2,
    FuncP2)

返回指向函数的指针 和数组类似(6.3.3节)，虽然不能返回一个函数，但是能返回指向函数类型的指针。

我们必须把返回类型写成指针形式。 简化的写法是使用类型别名。

using F = int (int *, int); // F是函数类型，不是指针
using PF = int(*) (int *, int); // PF是指向函数的指针

需要注意的是返回类型不会(像作为形参的函数一样)自动转换成指针，必须显示地将返回类型定义为指针

PF f1(int);     // 正确：PF是指向函数的指针，f1返回指向函数的指针
F f1(int);  // 错误，F是函数类型，不能返回一个函数类型
F* f1(int);  // 正确，返回一个指向F类型的函数的指针

/* 
    直接声明
*/
int (*f1(int))(int *, int);
// f1形参是int
// 返回是指向函数类型为int (*)(int *, int)的一个指针

将auto和decltype用于函数指针类型

如果明确知道返回的函数是哪一个，就可以使用decltype来简化返回指针的函数的声明。

需要注意的是使用decltype时，返回的是函数类型，而非指向函数的指针，所以我们需要显式地加上*以表明我们需要返回的是指针，而非函数本身

（同样的，decltype也不会将数组名转换成指针，需要在函数声明处添加一个*表示函数返回的是一个指针，参考4.11.2节，6.3.3节）

auto f1(int) -> int (*)(int*, int);

string::size_type sumLength(
    const string &s1, 
    const string &s2);
string::size_type largerLength(
    const string &s1, 
    const string &s2);

/* getFunc内部的返回值是sumLength、largerLength其中一种
   因为两种的数据类型相同，所以选其一decltype(largerLength)即可
 */
decltype(largerLength) *getFunc(const string&);

第七章 类

在C++中，我们使用类定义自己的数据类型。 通过定义新的类型来反映待解决的问题中的各种概念，可以使我们更容易编写、调试和修改程序

本章是第二章关于类的话题的延续，主要关注数据抽象的重要性。 数据抽象能帮助我们将对象的具体实现与对象能执行的操作分离开来。

第13章讨论如何控制对象拷贝、移动、赋值和销毁等问题 第14章中我们将学习如何自定义运算符

类的基本思想是数据抽象和封装。 数据抽象是一种依赖于接口和实现分离的编程技术

类的接口包括用户所能执行的操作 类的实现包括类的 数据成员、负责接口实现的函数体以及定义类所需的各种私有函数

封装使得类的接口和实现分离，封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分。

类要想实现数据抽象和封装，需要首先定义一个抽象数据类型

7.1 定义抽象数据类型

Sales_item是一个抽象数据类型，Sales_item类有一个名为isbn的成员函数，并且支持+、=、+=、<<和>>运算符。

我们在14章学习如何自定义运算符。现在我们将这些运算定义为普通函数形式：定义一个Sales_data

• 一个isbn成员函数，返回ISBN编号
• 一个combine成员函数，用于将一个Sales_data对象加到另一个Sales_data对象上
• 一个add函数，执行两个Sales_data对象的加法
• 一个read函数，将数据从istrearm读入到Sales_data对象中
• 一个print函数，将Sales_data对象的值输出到ostrearm

使用改进的Sales_data类 在考虑如何实现我们的类之前，首先来看看应该（想要）如何使用这些接口函数

    Sales_data total;
    if (read(cin, total)) {
        Sales_data trans;

        while (read(cin, trans)) {
            if(total.isbn() == trans.isbn()){
                total.combine(trans);
            }else{
                print(cout,total) << endl;
                total = trans;
            }
        }
        print(cout, total) << endl;
    } else{
        cerr << "No data!?" << endl;
    }