1.2 初始输入输出

• iostream库为IO库,其中包含两个基本类型istream和ostream,分别表示输入流和输出流
  • 一个流就是一个字符序列,是从IO设备读出或写入IO设备的
• 标准输入输出对象
  • cin标准输入
  • cout标准输出
  • cerr输出警告和错误信息,标准错误
  • clog输出程序运行时的一般性信息
• 向流中写入数据
  • 输出运算符<<
    • 接受两个运算对象,左边为ostream对象,右边为要打印的值
    • std::endl为操纵符：结束当前行,并将与设备关联的缓冲区中的内容刷到设备中
      • 缓冲刷新操作可以保证到目前为止程序所产生的所有输出真正写入输出流中,而不是仅停留在内存中等待写入流
• 从流中读取数据
  • 输入运算符>>

2 变量和基本类型

2.1 基本内置类型

• C++规定,一个int至少和一个short一样大,一个long至少和一个int一样大,一个long long至少和一个long一样大
  • long long在C++11中新定义
  • 一个字节为8bit,一个字32或64bit
• 带符号类型和无符号类型
  • int,short,long和long long都是带符号的,在类型名前添加unsigned就可以得到无符号类型
  • char,signed,unsigned char：char,signed并不一样
• 类型转换
  • 赋给带符号类型一个超出表示范围的值时,结果是未定的
  • 切勿混用带符号类型和无符号类型
• 字面值常量
  • 以0开头的整数表示八进制数,以0x开头的整数表示十六进制数
  • 浮点数字面值表现位一个小数或以科学计数法表示的指数,其中指数部分用E标识,默认的浮点型字面值为double
  • 单引号括起来的单个字符称为char型字面值,双括号括起来的零个或多个字符则构成字符串型字面值
    • 字符串字面值实际上是由常量字符构成的数组,在末尾处有’\0’
  • 转义字符：以反斜线作为开始
    • 泛化的转义序列,其形式是\x后紧跟1个或多个十六进制,或者紧跟八进制数字,其中数字部分表示的是字符对应的数值
  • 指定字面值的类型：添加前缀和后缀可以改变整型、浮点型和字符型字面值的默认类型
    • 如果后缀中有U,则该字面值属于无符号类型
    • 如果后缀中有L,则字面值的类型至少是long
    • 如果后缀中有LL,则字面值的类型将是long long和unsigned long long 中的一种
  • nullptr是指针字面值

2.2 变量

• C++是一种静态类型语言,其含义是在编译阶段检查类型
• 何为对象：对象是指一块能存储数据并具有某种类型的内部空间
• C++中,初始化和赋值为两个概念
  • C++11,引入列表初始化：用花括号来初始化变量
• 默认初始化：内置类型的变量未被显式初始化,值由定义的位置决定,定义于任何函数体之外的变量被初始化为0
  • 定义在函数体内部的内部的内置类型变量将不被初始化
  • 一个未被初始化的内置类型变量的值是未被定义的
  • 一些类要求每个对象都显式初始化,如果创建了一个该类的对象而未对其做明确的初始化操作,将引发错误
• 分离式编译
  • C++将声明和定义区分开,声明使得名字为程序所致,定义负责创建实体
    • 变量声明规定了变量的类型和名字,同时申请存储空间
  • 声明变量而不定义,需要在变量名前添加extern,而且不要显式初始化变量
    • extern:标示变量或者函数的定义在别的文件中,提示编译器遇到此变量和函数时在其他模块中寻找其定义
      • 在函数体内部,尝试初始化一个由extern关键字标记的变量将会引发错误
  • 任何显式初始化的声明为定义
  • 变量只能被定义一次,但可以声明多次,变量的定义必须出现在且只能出现在一个文件中,而其他用到该变量的文件必须对其进行声明,却绝对不能重复定义
• 标识符
  • C++的标识符由字母、数字和下画线组成,其中必须以字母或下画线开头
  • 标识符的长度没有限制,但是对大小写字母敏感

1
2
3
4
5
6
7
8
9
10

// 定义变量并初始化
int units_sold = 0;
int units_sold = {0};
int units_sold{0};
int units_sold(0);

// 声明变量而不定义
extern int i;
// 声明并定义j
int j;

2.3 复合类型

2.3.1 引用

• 引用为对象起了另一个名字,引用类型引用另外一种类型,通过将声明符携程&d的形式来定义引用类型,其中d是声明的变量名
• 一般在初始化变量时,初始值会被拷贝到新建的对象中,然而定义引用时,程序会把引用和它的初始值绑定在一起,而不是将初始值拷贝给引用
  • 引用必须初始化(引用无法令引用重新绑定到另外一个对象)
  • 一旦初始化完成,引用将和它的初始值对象一直绑定在一起
  • 定义了一个引用之后,对其进行的所有操作都是在与之绑定的对象上进行的

2.3.2 指针

• 与引用类似,指针也实现了对其他对象的间接访问
• 指针与引用相比又有很多不同点
  1. 指针本身就是一个对象,允许对指针赋值和拷贝,而且在指针的生命周期内它可以先后指向几个不同的对象
  2. 指针无须在定义时赋初值。和其他内置类型一样,在块作用域内定义的指针如果没有被初始化,也将拥有一个不确定的值
• 定义指针类型的方法将声明写出*d的形式,其中d式变量名
  • 在声明语句中指针的类型实际上被用于指定它所指向对象的类型,二者必须匹配。如果指针指向了一个其他类型的对象,对该对象的操作将发生错误
  • 获取对象的地址,需要使用取地址符&
• 指针值的4种状态
  • 指向一个对象
  • 指向紧邻对象所占空间的下一个位置
  • 空指针
  • 无效指针
    • 试图拷贝或以其他方式访问无效指针的值都将引发错误
• 指针访问对象,需要使用解引用符*访问对象
  • 对指针解引用会得出所指的对象,若给解引用的结果赋值,实际上也就是给指针所指的对象赋值
  • 解引用操作只适用于指向了某个对象的有效指针
• 空指针
  • C++11引入的新方法,使用nullptr初始化指针
  • nullptr是一种特殊类型的字面值,可以转换成任意其他类型的指针类型
  • NULL的预处理变量来给指针赋值,其值为0,定义在cstdlib中
• 赋值和指针
  • 指针和引用都能提供对其他对象的间接访问,在具体实现细节上二者有很大不同,其中最重要的一点就是引用本身并非一个对象
    • 一旦定义了引用,就无法令其再绑定到另外的对象,之后每次使用这个引用都是访问它最初绑定的那个对象
  • 指针和它存放的地址之间就没有这种限制了。和其他任何变量(只要不是引用)一样,给指针赋值就是令它存放一个新的地址,从而指向一个新的对象
• 任何非0指针对应的条件值都是true
• void* 指针
  • 特殊的指针类型,可以存放任意对象的地址
  • 利用void*指针能做的事儿比较有限：拿它和别的指针比较、作为函数的输入或输出,或者赋给另外一个void*指针
    • 不能直接操作void*指针所指的对象
  • 以void*的视角来看内存空间也就仅仅是内存空间,没办法访问内存空间中所存的对象

2.3.3 理解复合类型

• 定义包括一个基本数据类型和一组声明符
• 定义多个变量时,基本数据类型是基本数据类型而非基本类型*,*仅仅是修饰了变量名而已
  • 将*或&与变量名连在一起
• 指向指针的指针
  • **表示指向指针的指针
  • 解引用指向指针的指针会得到一个指针
  • 两次解引用指向指针的指针会得到最原始的对象
• 指向指针的引用
  • 引用本身不是一个对象,不能定义指向引用的指针,但指针是对象,所以存在对指针的引用
  • *&r,理解时最简单的办法是从右向左阅读r的定义;离变量名最近的符号(此例中是&r的符号&)对变量的类型有最直接的影响,因此r是一个引用;声明符的其余部分用以确定r引用的类型是什么,此例中的符号*说明r引用的是一个指针;声明的基本数据类型部分指出r引用的是一个int指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int *p;  //定义指向int型对象的指针

int ival = 42;
int *p = &ival;     //p存放ival的地址,p式指向变量ival的指针

int* p1,p2;     //p1为一个指向int的指针,p2为int类型

int **pp = &p;    //pp1表示指向一个int指针的指针

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

r = &i; //r引用了一个指针,因此给r赋值&i就是令p指向i
*r = 0; //解引用r得到i,也就是p指向的对象,将i的值改为0
//要理解r的类型到底是什么,最简单的办法是从右向左阅读r的定义
//离变量名最近的符号(此例中是&r的符号&)对变量的类型有最直接的影响,因此r是一个引用
//声明符的其余部分用以确定r引用的类型是什么,此例中的符号＊说明r引用的是一个指针
//最后,声明的基本数据类型部分指出r引用的是一个int指针

2.4 const限定符

• const限定符对变量的类型加以限制可以防止程序改变变量的值
• const变量一旦创建其值就不能再改变,故const变量必须初始化
• 默认状态下,const对象仅在文件内有效
  • 编译器在编译过程中将变量全部替换成对应的值
  • 当多个文件中出现了同名的const变量时,在不同文件中分别定义了独立的变量
  • 文件共享const变量时,对const变量的声明和定义都添加extern关键字

2.4.1 const引用(常量引用)

• 将引用绑定在const对象上,是对常量的引用
  • const引用与普通引用的不同：对常量的引用不能被用于修改它绑定的对象
• 引用的类型必须与其所引用对象的类型一致
  • 在初始化常量引用时允许用任意表达式作为初始值,只要其结果可以转换成引用的类型即可
• 常量引用一个非const的对象：不允许通过常量引用修改对象的值

2.4.2 const和指针

• const指针(常量指针)：指向常量的指针,不可以修改其所指向对象的值
  • 常量指针为底层指针,表示指针指向的是常量
  • 常量只可以使用指向常量的指针存放常量的地址
  • 常量指针可以指向其他对象,但不可以通过常量指针修改对象的值
  • 常量指针必须初始化,一旦初始化完成,指针不可以改变
• 指针常量：把*放在const关键字之前说明指针是一个常量,即不变的是指针本身的值而非指向的那个值
  • 指针常量为顶层const,指针本身就是常量
  • 指针本身是一个常量并不意味着不能通过指针修改其所指对象的值,能否这样做完全依赖于所指对象的类型
• 注意区别指针常量和常量指针

2.4.3 顶层const和底层const

• 顶层const表示任意的对象是常量
• 底层const表示指向常量
• 顶层const拷贝时,顶层const不受影响
• 底层const拷贝时
  • 拷入和拷出时的对象必须具有相同的底层const
    • 或两个对象的数据类型必须可以转换

2.4.4 constexpr和常量表达式

• 常量表达式是指指不会改变并且在编译过程中就可以得到计算结果的表达式
• C++11中,允许变量声明为constexpr类型,以便编译器验证变量的值是否是常量表达式
  • 新标准允许定义一种特殊的constexpr函数(以使得编译时就可以计算其结果,可以用constexpr函数去初始化constexpr变量)
• 声明为constexpr的变量一定是一个常量,而且必须用常量表达式初始化
• 指针和引用定义成constexpr,constexpr指针初始化值必须是nullptr或0
• 指针和constexpr
• 在constexpr声明中定义了一个指针,限定符constexpr仅对指针有效,与指针所指的对象无关

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

int i = 42;
int &r1 = i;
const int &r2 = i;  //常量引用,但不可以通过其改变i的值

r1 = 0;
r2 = 0;     //错误;r2为常量引用

const double pi = 3.14;
double *ptr = π    //ptr为普通指针
const double *cptr = π   //指向常量的指针

const double *const cptr = π   //cptr是一个指向常量对象的常量指针
int *const ptri = &i;   //ptri是一个指向int的常量指针

int i = 0;
int *const p1 = &i;   //顶层const,不可以改变p1的值
const int ci = 42;    //顶层const,不可以改变
const int *p2 = &ci;  //底层const,可以改变p2的值
const int *const p3 = p2;   //左边的底层const,右边的顶层const
i = ci;     
p2 = p3;      //p2,p3所指向的对象类型相同,p3顶层const部分不影响

int *p = p3;    //错误,p不包含底层const含义
p2 = p3;      //正确
p2 = &i;      //正确,int*可以转换成const int*
int &r = ci;    //错误
const int &r2 = i;  //正确
//p3既是顶层const也是底层const
//拷贝p3时可以不在乎它是一个顶层const,但是必须清楚它指向的对象得是一个常量

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

2.5 处理类型

2.5.1 类型别名

• 类型别名是一个名字,是某种类型的同义词
• 传统方法：使用typedef
• C++11中使用别名声明,这种方法用关键字using作为别名声明的开始,其后紧跟着别名和等号,其作用是把等号左侧的名字规定成等号右侧类型的别名
  • 类型别名和类型的名字等价
• 指针,常量和类型别名
  • 在使用类型别名的声明语句时,不可以将别名替换成原来的样子,应将声明部分看成一个整体

2.5.2 auto类型说明符

• 在C++11中,引入auto修饰符,可以让编译器分析表达式所属的类型,推算变量的类型
• auto定义的变量必须给初始值
  • ==当引用被用作初始值时,真正参与初始化的其实时引用对象的值
  • auto一般会忽略顶层const,保留底层const,需要顶层const时需要明确指出
  • ==设置一个类型为auto的引用,初始化中的顶层const属性会保留
• ==一条语句中定义多个变量,&,*只从属于某个声明符,而非基本数据类型的一部分

2.5.3 decltype类型指示符

• C++11引入的第二种类型说明符,选择并返回操作数的数据类型
• decltype处理顶层const和引用的方式与auto不同,若decltype使用的表达式是一个变量,则返回该变量的类型(包括顶层const和引用在内)
  • 引用从来都是作为其所指对象的同义词出现,但在decltype中例外
  • 如果decltype使用的表达式不是一个变量,则decltype返回表达式结果对应的类型
  • 如果表达式内同是解引用操作,则decltype将得到引用类型
  • 如果decltype使用的是一个不加括号的变量,则得到的结果就是该变量的类型
  • 如果给变量加上了一层或多层括号,编译器就会把它当成是一个表达式,得到引用类型(变量是一种可以作为赋值语句左值的特殊表达式)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

typedef char *pstring;
const pstring cstr = 0;   //cstr是指向char的常量指针
const pstring *ps;  //ps是一个指针,其对象是指向char的常量指针

int i = 0, &r = i;
auto a = r; //a为int类型

const int ci = i, &cr = ci;
auto b = ci;  //b整型(ci的顶层const属性被忽略)
auto c = cr;  //c整型
auto d = &i;
auto e = &ci;   //指向整型常量的指针

const auto f = c; //  const int 

auto &g = 42; //错误
const auto &j = 42; //正确,可以为常量引用绑定字面值

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

int i = 42,*p = &i, &r = i;
decltype(r+0) b;  //  int
decltype(*p) c;   //错误,c时int&,必须初始化
// r是一个引用,因此结果为引用类型
// 但向让结果类型r是所指向的类型,需要使用表达式

decltype((i)) d;  //d,int&必须初始化
decltype(i) e;  //int

2.6 自定义数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13

// 结构体的定义
Struct 结构体名{
  成员变量;
  成员函数;
};

// 头文件保护符
#ifdef 头文件
#define 头文件
// ...
// 头文件内容
// ...
#endif

3 字符串,向量和数组

3.1 命名空间的using声明

• using声明可以使用命名空间中的成员
  • 每个名字都需要独立的using声明
  • 头文件不应包含using声明

1
2

// using声明
using namespace::name;

3.2 标准库类型string

• 标准库类型string表示可变长字符序列,包含在string头文件中
• 定义和初始化string对象
• 使用=初始化变量,执行拷贝初始化,不使用=进行直接初始化
• string操作的注意事项
  • getline函数的参数是一个输入流和一个string对象,函数从给定的输入流中读入内容,直到遇到换行符为止(注意换行符也被读进来了)
    • >>不会保留输入时的空白符,遇空白符停止
  • string::size_type类型
    • 所有用于存放string类的size函数返回值的变量,都是string::size_type类型的
    • 在C++11中,允许编译器通过auto或者decltype来推断变量的类型
      • 避免因为符号数和无符号数产生意外的结果
• C++11引入范围for语句
  • 遍历给定序列中的每个元素并对序列中的每个值执行某种操作
  • for(declaration:expression)
  • expression部分是一个对象,用于表示一个序列;declaration部分负责定义一个变量,该变量将被用于访问序列中的基础元素;每次迭代,declaration部分的变量会被初始化为expression部分的下一个元素值
    • auto c可作为declaration部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include<string>
using std::string;

string s1;    //默认初始化
string s2 = s1; // 拷贝初始化
string s2(s1);  // 拷贝初始化
string s3 = "hiya";   //拷贝初始化
string s3("hiya");   //直接初始化
string s4(10,'c');    //cccccccccc

// 读写string对象
int main(){
  string s;
  cin>>s;
  cout<<s<<endl;
  return 0;
}

// 读写数量未知的string
int main(){
  string word;
  while(cin>>word)
    cout<<word<<endl;
  return 0;
}

// auto推断
auto len = line.size(); //len string::size_type

// 范围for
for(declaration:expression)
  statement

3.3 标准库类型vector

• 标准库类型vector表示对象的集合,其中所有对象的类型都相同,常被称为容器
  • 集合中每个对象都有一个与之对应的索引,索引用于访问对象
  • vector属于类模板
    • 编译器根据模板创建类或函数的过程称为实例化,在模板名后跟着一对尖括号,在括号内放上信息,即可创建模板实例类
  • vector能容纳绝大多数类型的对象作为其元素,但引用不属于对象,不存在包含引用的vector
• 定义和初始化vector对象
  • 定义一个空vector,然后当运行时获取到元素的值后再逐一添加(在程序运行时高效地往vector对象中添加元素)
  • 在定义对象时指定元素的初始值
  • C++11中可以使用列表初始化,用花括号括起来的元素值赋值给vector对象
  • 用圆括号初始化指定的一般为数量,用花括号初始化的为初始化列表
• 向vector对象中添加元素
  • 使用push_back向vector对象添加元素,将值作为尾元素压入vector中
    • vector对象(以及string对象)的下标运算符可用于访问已存在的元素,而不能用于添加元素
    • 添加元素后再分配内存空间,声明定义只是开辟内存头
  • vector对象可以高效地增长,可以快速添加元素
  • 如果循环体内部包含有向vector对象添加元素的语句,则不能使用范围for循环

1
2
3
4
5
6
7

#include<vector>
usind std::vector;

vector<int> ivec;

// 添加元素
ivec.push_back(1);  //向ivec中添加元素

3.4 迭代器介绍

• 标准库容器可以使用迭代器,迭代器类似指针类型,提供了对对象的间接访问
  • 使用迭代器可以访问某个元素,迭代器也能从一个元素移动到另一个元素;有效的迭代器指向某个元素或容器尾元素的下一个位置
• 使用迭代器
  • 有迭代器的类型同时拥有返回迭代器的成员,这些类型拥有begin和end成员
    • begin成员负责指向第一个元素的迭代器
    • end成员负责指向尾元素的下一个位置,指示的是容器一个不存在的尾后元素,迭代器称为尾后迭代器
    • 由编译器决定迭代器的类型,一般使用auto关键字定义变量
    • 若容器为空,begin和end返回的是一个迭代器,都是尾后迭代器
  • 和指针类似,可通过解引用迭代器来获取它所指示的元素
• begin和end返回的具体类型由对象是否是常量决定
  • 如果对象是常量,begin和end返回const_iterator
  • 如果对象不是常量,返回iterator
• 拥有迭代器的标准库类型使用iterator和const_iterator来表示迭代器类型
  • const_iterator为常量,可以读取但不能修改它所指向的元素值
    • C++11中引入cbegin和cend获得const_iterator
• C++语言定义了箭头运算符->, 箭头运算符把解引用和成员访问两个操作结合在一起,it->mem等价于(*it).mem

1
2
3
4
5
6
7

auto b = v.begin(),e=v.end();

//拥有迭代器的标准库类型使用iterator和const_iterator来表示迭代器类型
vector<int>::iterator it; //it可以读写vector<int>的元素
string::iterator it; //it可以读写String的元素
vector<int>::const_iterator it; //it可以读vector<int>的元素,但不可以写
string::const_iterator it; //it可以读String的元素

3.5 数组

• 数组与vector的区别
  • 与vector相似的地方是,数组也是存放类型相同的对象的容器,这些对象本身没有名字,需要通过其所在位置访问
  • 与vector不同的地方是,数组的大小确定不变,不能随意向数组中增加元素
• 定义和初始化数组
  • 数组为复合类型,默认情况下,数组的元素被默认初始化
  • 定义数组的时候必须指定数组的类型,不允许用auto关键字由初始值的列表推断类型
  • 数组的元素应为对象,不存在引用的数组
  • 不能将数组的内容拷贝给其他数组作为其初始值,也不能用数组为其他数组赋值
• 访问数组元素
  • 可使用范围for语句
  • 使用数组下标时,通常定义为size_t类型,该类型在cstddef头文件中,是一种机器相关的无符号类型
• 复杂的数组声明
  • 指针数组：存放指针的数组
  • 数组指针：数组的指针及数组的引用
  • 要想理解数组声明的含义,最好的办法是从数组的名字开始按照由内向外的顺序阅读
• 复合类型的理解规则：从右到左,从内到外

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

unsigned cnt = 42;
constexpr unsigned sz = 42;   //常量表达式
int arr[10];
int *parr[sz];  //含有42个整型指针的数组
string bad[cnt];  //cnt不是常量表达式,错误
string strs[get_size()];    //get_size()为常量表达式时正确

int ial[sz] = {0,1,2};
int a2[] = {0,1,2};
int a3[5] = {0,1,2};  //a3[] = {1,2,3,0,0}

char a1[] = {'c','+','+'};  //列表初始化,没有空字符
char a1[] = {'c','+','+','\0'};  //列表初始化,含有显式空字符
char a1[] = "C++";  //列表初始化,含有隐式空字符,表示字符串结束的空字符 size(a1)=4

int *ptrs[10];    //ptrs是含有10个整型指针的数组,指针数组
int (*Parray)[10] = $arr; //Parry指向一个含有10个整数的数组,数组指针
int (&arrRef)[10] = arr; //arrRef引用一个含有10个整数的数组
int *(&arrRef)[10] = ptrs;  //arrRef是一个引用,引用一个指针数组,该数组包含10个指针

3.5.3 指针和数组

• 使用数组时编译器一般会将数组转换为指针
• 对数组使用下标运算符得到该数组指定位置的元素
  • 对数组元素使用取地址符能得到指向该元素的指针
  • 数组名为一个指向数组首地址的指针
  • 当使用数组作为一个auto变量的初始值时,推断得到的类型是指针而非数组
    • 使用decltype关键字时不会发生转换
• 指针作为迭代器
  • 若得到尾后指针,使用时容易出错
  • C++11新标准引入了两个名为begin和end的函数,可得到指向元素的首指针和尾元素下一个位置的指针,定义在iterator头文件中
  • 指针可执行所有迭代器运算,包括解引用、递增、比较、与整数相加、两个指针相减等,用在指针和用在迭代器上意义完全一致
  • 两指针相减时,得到ptrdiff_t的标准库类型,与size_t一样,是一种定义在cstddef头文件中的机器相关的类型
    • 因为差值可能为负值,所以ptrdiff_t是一种带符号类型
  • 两个指针指向同一个数组的元素,或者指向该数组的尾元素的下一位置,可利用关系运算符进行比较,否则不可以比较
  • 对数组执行下标运算其实是对指向数组元素的指针执行下标运算
    • 只要指针指向的是数组中的元素(或者数组中尾元素的下一位置),都可以执行下标运算
    • 标准库类型限定使用的下标必须是无符号类型,而内置的下标运算可以是有符号类型
    • 内置的下标运算符可以处理负值,结果地址必须指向原来的指针所指同一数组中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13

string nums = {"one","two","three"}
string *p = &nums[0];

string *p2 = nums;  //等价于*p2=&num[0]

int ia[] = {0,2,3,4,5,6};
auto ia2(ia); //ia2为一个整型指针,指向ia的第一个元素

decltype(ia) ia3={0,1,2}; //ia3为一个整型数组

int *p = &ia[2];    //p指向索引为2的元素
int j = p[1];       //相当于*(p+1),ia[3]
int k = p[-2];      //p[-2]是ia[0]表示的元素

3.5.4 C风格字符串

• C风格的字符串为char数组,并以空字符(‘\0’)结束
  • 一般利用指针来操作这些字符串

3.5.5 与旧代码的接口

• string的c_str成员函数：将string转换为c风格的字符串
  • 函数的返回结果是一个指针,该指针指向一个以空字符结束的字符数组,而这个数组所存的数据恰好与那个string对象的一样
  • 指针的类型是const char*,从而确保我们不会改变字符数组的内容
• 不允许使用一个数组为另一个内置类型的数组赋初值,也不允许使用vector对象初始化数组
  • 允许使用数组来初始化vector对象
  • 需指明要拷贝区域的首元素地址和尾后地址
• 尽量使用标准库类型而非数组

1
2
3

int int_arr[] = {0,1,2,3,4,5};
vector<int> ivec(begin(int_arr),end(int_arr));
vector<int> ivec(int_arr+1,int_arr+4);    //拷贝3个元素,int_arr[1]~[3]

3.6 多维数组

• 多维数组初始化时,使用花括号进行初始化,可嵌套使用花括号
• 可使用范围for语句处理多维数组
  • 使用范围for语句处理多维数组,除了最内层的循环外,其他所有循环的控制变量都应该是引用类型
  • 定义多维数组的指针时,多维数组其实是数组的数组
  • 使用auto或者decltype能尽可能地避免在数组前面加上一个指针类型

1
2
3
4
5
6

// 输出is中的每个元素的值,ia为二维数组,每个内层数组各占一行ia[3][4]
for(auto p = ia;p!=ia+3;++p){
  for(auto q = *p;q!=*p+4;++q)
    cout<<*q<<' ';
  cout<<endl;
}

4 表达式

4.1 基础

• 重载运算符：当运算符作用与类类型的运算对象时,可以自定其含义
  • 定义重载运算符时,其包括的运算对象的类型和返回值的类型都是由运算符定义的;但运算对象的个数,运算符的有限集和结合律都是无法改变的
• 左值和右值
  • 左值可以位于赋值语句的左侧,右值则不能
  • 当一个对象被用作右值的时候,用的是对象的值(内容)
    • 当对象被用作左值的时候,用的是对象的身份(在内存中的位置)
  • 在需要右值的地方可以用左值来代替,但是不能把右值当成左值(也就是位置)使用
    • 当一个左值被当成右值使用时,实际使用的是它的内容(值)
  • 使用关键字decltype时,左值和右值也有所不同
    • 如果表达式的求值结果是左值,decltype作用于该表达式得到一个引用类型

4.2 算数运算符

• 算数运算符包括
  • + 加
  • - 减
  • * 乘
  • / 除
  • % 取余
• C++11中,规定商一律向0取整(即直接切除小数部分)

4.3 逻辑和关系运算符

• 逻辑和关系运算符包括

  • 逻辑非 !
  • 小于 <
  • 大于 >
  • 小于等于 <=
  • 大于等于 >=
  • 相等 ==
  • 不相等 !=
  • 逻辑与 &&
  • 逻辑或 ||

• 短路求值:逻辑与运算符和逻辑或运算符都是先求左侧运算对象的值再求右侧运算对象的值,当且仅当左侧运算对象无法确定表达式的结果时才会计算右侧运算对象的值

  • 对于逻辑与运算符来说,当且仅当左侧运算对象为真时才对右侧运算对象求值
  • 对于逻辑或运算符来说,当且仅当左侧运算对象为假时才对右侧运算对象求值

4.4 赋值运算符

• 赋值运算符的左侧运算对象必须是一个可修改的左值
• C++11允许使用花括号括起来的初始值列表跳转至列表初始化作为赋值语句的右侧运算对象
• 赋值运算符的优先级低于关系运算符的优先级

4.5 递增和递减运算符

• 前置版本++v
  • 首先将运算对象加1(或减1),然后将改变后的对象作为求值结果
• 后置版本
  • 将运算对象加1(或减1),但是求值结果是运算对象改变之前那个值的副本
• 除非必须,否则不用递增递减运算符的后置版本
• 后置递增运算符的优先级高于解引用运算符

4.6 成员访问运算符

• 点运算符和箭头运算符都可以访问成员
  • 点运算符获取类对象的一个成员
  • 箭头运算符与点运算符有关,表达式ptr->mem等价于(*ptr).mem
• 箭头运算符作用于一个指针类型的运算对象,结果是一个左值
• 点运算符分成两种情况：
  • 如果成员所属的对象是左值,那么结果是左值;
  • 反之,如果成员所属的对象是右值,那么结果是右值

1
2
3
4

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

4.7 条件运算符

• 条件运算符 cond?expr1:expr2;
  • 其中cond是判断条件的表达式,而expr1和expr2是两个类型相同或可能转换为某个公共类型的表达式
  • 条件运算符的执行过程是：首先求cond的值,如果条件为真对expr1求值并返回该值,否则对expr2求值并返回该值
• 条件运算的嵌套最好别超过两到三层

4.8 位运算符

• 位运算符作用于整数类型的运算对象,并把运算对象看成是二进制位的集合
• 一种名为bitset的标准库类型也可以表示任意大小的二进制位集合
• 位运算符包括
  • 位求反 `
  • 左移 <<
  • 右移 >>
  • 位与 &
  • 位异或 ^
  • 位或 |
• 强烈建议仅将位运算符用于处理无符号类型

4.9 sizeof运算符

• sizeof运算符返回一条表达式或一个类型名字所占的字节数
• sizeof运算符满足右结合律,其所得的值是一个size_t类型,是一个常量表达式
• 形式1：sizeof(type)
• 形式2：sizeof expr
  • sizeof返回的是表达式结果类型的大小,sizeof并不实际计算其运算对象的值
• 执行sizeof运算能得到整个数组的大小,可以用数组的大小除以单个元素的大小得到数组中元素的个数

1
2
3

// 返回数组中的元素数量
constexpr size_t sz = sizeof(ia)/sizeof(*ia);
int arr2[sz];

4.10 逗号运算符

• 逗号运算符含有两个运算对象,按照从左向右的顺序依次求值
• 对于逗号运算符来说,首先对左侧的表达式求值,然后将求值结果丢弃掉。逗号运算符真正的结果是右侧表达式的值。如果右侧运算对象是左值,那么最终的求值结果也是左值

4.11 类型转换

• 隐式转换
  • 在大多数表达式中,比int类型小的整型值首先提升为较大的整数类型
  • 在条件中,非布尔值转换成布尔类型
  • 初始化过程中,初始值转换成变量的类型;在赋值语句中,右侧运算对象转换成左侧运算对象的类型
  • 如果算术运算或关系运算的运算对象有多种类型,需要转换成同一种类型
  • 函数调用时也会发生类型转换
• 算术转换：把一种算术类型转换成另外一种算术类型,其中运算符的运算对象将转换成最宽的类型
• 数组转换成指针：在大多数用到数组的表达式中,数组自动转换成指向数组首元素的指针
• 指针的转换
  • 常量整数值0或者字面值nullptr能转换成任意指针类型
  • 指向任意非常量的指针能转换成void*
  • 指向任意对象的指针能转换成const void*
  • 在有继承关系的类型间还有另外一种指针转换的方式
• 转换成布尔类型
  • 存在一种从算术类型或指针类型向布尔类型自动转换的机制。如果指针或算术类型的值为0,转换结果是false;否则转换结果是true
• 转换成常量
  • 允许将指向非常量类型的指针转换成指向相应的常量类型的指针,对于引用也是这样。也就是说,如果T是一种类型,就能将指向T的指针或引用分别转换成指向const T的指针或引用
• 类类型定义的转换

4.11.3 显式转换

• 显式转换为强制类型转换
• 命名的强制类型转换 cast-name<type>(expression);
  • type是转换的目标类型而expression是要转换的值
  • 如果type是引用类型,则结果是左值
  • cast-name是static_cast、dynamic_cast、const_cast和reinterpret_cast中的一种
• static_cast
  • 任何具有明确定义的类型转换,只要不包含底层const,都可以使用static_cast
  • static_cast可以将一个较大的算术类型赋值给较小的类型
  • static_cast对于编译器无法自动执行的类型转换也非常有用
  • 把指针存放在void*中,并且使用static_cast将其强制转换回原来的类型时,应该确保指针的值保持不变;强制转换的结果将与原始的地址值相等
  • 对右值引用的特许规则:虽然不能隐式地将一个左值转换成右值引用,但static_cast可以显式地将一个左值转换成一个右值
• const_cast
  • “去掉const性质”：将常量对象转换成非常量对象的行为
  • 只有const_cast能改变表达式的常量属性,使用其他形式的命名强制类型转换改变表达式的常量属性都将引发编译器错误
• reinterpret_cat
  • 为运算对象的位模式提供较低层次上的重新解释

1
2
3
4
5

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

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

5 语句

5.3 条件语句

• C++语言提供了两种按条件执行的语句
  • 一种是if语句,它根据条件决定控制流
  • 另外一种是switch语句,它计算一个整型表达式的值,然后根据这个值从几条执行路径中选择一条
• 悬垂else
  • 当一个if语句嵌套在另一个if语句内部时,很可能if分支会多于else分支
  • C++规定else与离它最近的尚未匹配的if匹配
• switch-case-default

5.4 迭代语句

• 迭代语句通常称为循环,它重复执行操作直到满足某个条件才停下来
  • while和for语句在执行循环体之前检查条件
  • do while语句先执行循环体,然后再检查条件
• 范围for语句for(declaration : expression) statement
  • expression表示的必须是一个序列
  • declaration定义一个变量,序列中的每个元素都得能转换成该变量的类型;确保类型相容最简单的办法是使用auto类型说明符
    • 需要对序列中的元素执行写操作,循环变量必须声明成引用类型
  • 每次迭代都会重新定义循环控制变量,并将其初始化成序列中的下一个值,之后才会执行statement

5.5 跳转语句

• C++语言提供了4种跳转语句：break,continue,goto和return
• break语句负责终止离它最近的while、do while、for或switch语句,并从这些语句之后的第一条语句开始继续执行
  • break语句只能出现在迭代语句或者switch语句内部
• continue语句终止最近的循环中的当前迭代并立即开始下一次迭代
  • continue语句只能出现在for、while和do while循环的内部,或者嵌套在此类循环里的语句或块的内部
• goto语句的作用是从goto语句无条件跳转到同一函数内的另一条语句
  • 不要在程序中使用goto语句,因为它使得程序既难理解又难修改
  • goto label;其中,label是用于标识一条语句的标示符
  • 带标签语句是一种特殊的语句,语句之前有一个标示符以及一个冒号:
• return

5.6 try语句块和异常处理

• C++的异常处理包括
  • throw表达式,异常检查部分使用throw表达式表示遇到了无法处理的问题
  • try语句块,异常处理部分使用try语句块处理异常,try-catch语句块
  • 一套异常类,用于在throw表达式和相关的catch子句之间传递异常的具体信息

5.6.1 throw表达式

• throw表达式包含关键字throw和紧随其后的一个表达式,其中表达式的类型就是抛出的异常类型

1
2
3

if(item1.isbn() != item2.isbn())
  throw runtime_error("Data must refer to same ISBN");    // throw表达式
cout << item1 + item2 << endl;

5.6.2 try语句块

• try语句块内声明的变量在块外部无法访问,特别是在catch子句内也无法访问

1
2
3
4
5
6
7
8

// try语句块通用语法结构
try{
  program-statements
}catch(exception-declaration){
  handler-statements
}catch(exception-declaration){
  handler-statements
}

5.6.3 标准异常

• C++标准库定义了异常类
  • exception头文件定义了最通用的异常类exception;只报告异常的发生,不提供任何额外信息
  • stdexcept头文件定义了几种常用的异常类,详细信息在表5.1中列出
  • new头文件定义了bad_alloc异常类型
  • type_info头文件定义了bad_cast异常类型
• 标准库异常类只定义了几种运算,包括创建或拷贝异常类型的对象,以及为异常类型的对象赋值
• 只能以默认初始化的方式初始化exception、bad_alloc和bad_cast对象,不允许为这些对象提供初始值
  • 其他异常类型不允许使用默认初始化的方式：应该使用string对象或者C风格字符串初始化这些类型的对象;当创建此类对象时,必须提供初始值,该初始值含有错误相关的信息
• 异常类型只定义了一个名为what的成员函数,该函数没有任何参数,目的是提供关于异常的一些文本信息,返回值是一个指向C风格字符串的const char*

6 函数

6.1 函数基础

• 典型的函数包括：返回类型,函数名字,由0个或多个形参组成的列表以及函数体
• 通过调用运算符来执行函数,调用运算符的形式是一对圆括号,作用于一个表达式,该表达式是函数或者指向函数的指针
• 实参和形参
  • 实参是形参的初始值
  • 实参的类型必须与形参类型匹配
  • 任意两个形参都不能同名,而且函数最外层作用域中的局部变量也不能使用与函数形参一样的名字
  • 是否设置未命名的形参并不影响调用时提供的实参数量
    • 即使某个形参不被函数使用,也必须为它提供一个实参
• 函数的返回类型不能是数组或函数类型,但可以是指向数组或函数的指针

6.1.1 局部对象

• 形参和函数体内部定义的变量称为局部变量
• 对函数而言是局部的,仅在函数的作用域内可见,同时局部变量会隐藏在外层作用域中同名的其他所有声明
• 存在于块执行器件的对象称为自动对象,当块的执行结束后,块中创建的自动对象的值就为未定义的
  • 形参是一种自动对象,函数开始时为形参申请存储空间,函数终止,形参被销毁
• 局部静态对象
  • static类型：局部变量的生命周期贯穿函数调用及之后的时间
  • 局部静态对象在程序执行路径第一次经过对象定义语句时初始化,并且直到程序终止才被销毁,在此期间即使对象所在函数结束执行也不会对它有影响

6.1.2 函数声明

• 函数声明与函数定义类似,唯一的区别就是函数声明无需函数体,使用一个分号代替
• 函数的三要素(返回类型,函数名,形参类型)描述了函数接口,说明了调用该函数所需的全部信息
• 函数声明也叫做函数原型
• 建议在头文件中进行函数声明
  • 含有函数声明的头文件应该被包含到定义函数的源文件中

6.1.3 分离式编译

• 分离式遍历-链接形成可执行文件

6.2 参数传递

• 当形参是引用类型,对应的实参被引用传递或函数被传引用调用
• 当实参的值被拷贝给形参时,形参和实参是两个相互独立的对象,实参被值传递或函数被传值调用

6.2.1 传值参数

• 初始化一个非引用类型变量时,初始值被拷贝给变量
  • 对变量的改动不会影响初始值
  • 函数对形参的所有操作都不会影响实参
• 指针参数
  • 指针的行为和其他非引用类型一样
  • 当执行指针拷贝操作时,拷贝的是指针的值,拷贝之后,两个指针是不同的指针
  • 可以使用指针修改它所指向的对象的值(指针可以间接访问所指的对象)
• 在C++中,建议使用引用类型的形参代替指针访问函数外部的对象

6.2.2 传引用参数

• 引用的操纵实际上是作用在引用所引的对象上
• 通过使用引用形参,允许函数改变一个或多个实参的值
• 使用引用可以避免拷贝
• 函数无需修改引用形参的值,最好将其声明为常量引用
• 传递引用形参可以帮助返回额外信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

int n = 0, i = 42;
int &r = n;

//传递指针
void reset(int *ip){
  *ip = 0;  //改变了指针ip所指对象的值
  ip = 0;   //改变了ip的局部拷贝,实参未被改变
}
reset(&i);  //改变i的值,而非i的地址

//传递引用
void reset(int &i)  //i是传递给reset函数的对象的另一个名字
{
  i = 0;
}

int j = 42;
reset(j);   //传引用,j的值会发生改变

6.2.3 const形参和实参

• 顶层const和底层const
• 形参是const时,若为顶层const,初始化时会忽略顶层const属性
  • 底层const可以使用非常量进行初始化,反之不成立
  • C++允许用字面值初始化常量引用
• 尽量使用常量引用
  • 把函数不会改变的形参定义成普通的引用会给函数的调用者产生误导,即函数可以修改他的实参值
  • 使用引用而非常量引用也会极大地限制函数所能接受的实参类型,不能把const对象,字面值或需要类型转换的对象传递给普通的引用形参
  • 函数嵌套调用时,假如其他函数(正确地)将它们的形参定义成常量引用,那么内层函数(普通引用)无法正常使用

6.2.4 数组形参

• 数组的特殊性
  • 不允许拷贝数组
  • 使用数组时会将其转换成指针
• 数组进行传递时,传递的是指向数组首元素的指针,不可以进行值传递
  • 可以将形参携程类似数组的形式
  • 数组是以指针的形式传递给函数的,但需要指明数组的确切尺寸
    • 使用标记指定数组长度
    • 使用标准库规范,传递指向数组首元素和尾后元素的指针
    • 显式传递一个表示数组大小的形参
• 数组形参和const
  • 当函数不需要对数组元素执行写操作时,数组形参应该是指向const的指针,只有需要改变元素值是才定义为非常量的指针
• 数组引用形参
  • 形参可以是数组的引用,引用形参绑定到对应的数组上
• 传递多维数组
  • 处理的是数组的数组,首元素本身就是一个数组,指针就是一个指向数组的指针
  • 数组第二维(以及后面所有维度)的大小都是数组类型的一部分,不能省略

1
2
3
4
5
6
7
8
9
10
11

// const int ia[]等价于const int* ia
void print(const int ia[], size_t size)

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

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

6.2.5 main:处理命令行选项

• main函数传递实参可以通过命令行选项通过两个形参传递给main函数
• int main(int argv, char *argv[])
  • 第一个形参argc表示数组中字符串的数量
  • 第二个形参argv是一个数组,它的元素是指向C风格字符串的指针

6.2.6 含有可变形参的函数

• 编写处理不同数量实参的函数,两种方法
  • 如果实参类型相同,传递一个名为initializer_list的标准库类型
  • 如果实参的类型不同,编写可变参数模板函数
  • 利用省略符,传递可变数量的实参,一般只用于与C函数交互的接口程序
• 使用initializer_list类型的形参表示函数的实参数量未知但是全部实参的类型都相同
  • initializer_list是一种标准库类型,用于表示某种特定类型的值的数组
  • initializer_list类型定义在同名的头文件中
  • 和vector一样,initializer_list也是一种模板类型
    • 定义initializer_list对象时,必须说明列表中所含元素的类型
  • 和vector不一样的是,initializer_list对象中的元素永远是常量值,无法改变initializer_list对象中元素的值
• 省略符形参
  • 为了C++程序访问某些特殊的C代码而设置
  • 省略符形参应该仅仅用于C和C++通用的类型
    • 特别应该注意的是,大多数类类型的对象在传递给省略符形参时都无法正确拷贝
  • 省略符形参只出现在形参列表的最后一个位置

1
2
3
4
5
6
7
8
9
10

initializer_list<string> ls;
initializer_list<int> li;

void error_msg(initializer_list<string> il){
  for(auto beg = il.begin();beg != il.end();++beg)
    cout << *beg << " ";
  cout << endl;
}

void foo(parm_list, ...)    //省略符形参

6.3 返回类型和return语句

6.3.1 无返回值函数

• 没有返回值的return语句只能用在返回类型是void的函数中
• 返回void的函数不要求非得有return语句(会隐式地执行return)

6.3.2 有返回值的函数

• return语句提供了函数的结果
  • 只要函数的返回类型不是void,则该函数内的每条return语句必须返回一个值
  • return语句返回值的类型必须与函数的返回类型相同,或者能隐式地转换成函数的返回类型
• 值是如何被返回的
  • 返回一个值的方式和初始化一个变量或形参的方式完全一样：返回的值用于初始化调用点的一个临时量,该临时量就是函数调用的结果
  • 若函数返回引用,则该引用仅是它所引对象的一个别名
• 不要返回局部变量的引用或指针
  • 函数完成后,局部变量所占的存储空间被释放,随之指针和引用不再有效
• 引用返回左值
  • 调用一个返回引用的函数得到左值,其他返回类型得到右值
  • 可以像使用其他左值那样来使用返回引用的函数的调用,特别是,我们能为返回类型是非常量引用的函数的结果赋值
• 列表初始化返回值
  • C++11规定,函数可以返回花括号包围的值的列表
  • 类似于其他返回结果,此处的列表也用来对表示函数返回的临时量进行初始化
    • 如果列表为空,临时量执行值初始化;否则,返回的值由函数的返回类型决定
• 主函数main的返回值
  • 允许main函数没有return语句直接结束,编译器会隐式插入一条返回0的return语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

char &get_val(string &str,string::size_type ix){
  return str[ix];
}

int main(){
  string s("a value");
  get_val(s,0) = 'A';   //将s[0]值改为A 
}
// 返回值是引用,因此调用是个左值,和其他左值一样它也能出现在赋值运算符的左侧

vector<string> process(){
  //..
  if(expected.empty())
    return {};
  else if(expected == actual)
    return {"functionX","okay"};
  else
    return {"functionX",expected, actual};
}

6.3.3 返回数组指针

• 声明一个返回数组指针的函数
  • 定义一个返回数组指针的函数,数组的维度必须跟在函数名字之后
  • 函数的形参列表也跟在函数名字后面且形参列表应该先于数组的维度
  • Type (*function(parameter_list))[dimension]
• 尾置返回类型
  • 在C++11中引入尾置返回类型
  • 任何函数的定义都能使用尾置返回,但是这种形式对于返回类型比较复杂的函数最有效
  • 尾置返回类型跟在形参列表后面并以一个->符号开头
  • 为了表示函数真正的返回类型跟在形参列表之后,在本应该出现返回类型的地方放置一个auto
• 使用decltype
  • 知道函数返回的指针指向哪个数组就可以使用decltype关键字声明返回类型
  • decltype并不负责把数组类型转换成对应的指针,结果是个数组
  • 要想返回指针还必须在函数声明时加一个*符号

1
2
3
4
5
6
7
8
9
10

// 尾置返回类型
// 返回一个指针,该指针指向含有10个整数的数组
auto func(int) -> int (*)[10];

int odd[] = {1,3,5,7,9};
int even[] = {0,2,4,6,8};

decltype(odd) *arrPtr(int i){
  return (i%2):&odd:&even;
}

6.4 函数重载

• 重载函数：同一个作用域内的几个函数名字相同但形参列表不同的函数
  • main函数不能重载
• 定义重载函数
  • 重载函数在形参数量或形参类型上不同
  • 不允许两个参数除了返回类型外其他所有要素都相同
• 重载和const形参
  • 顶层const不影响传入函数的对象
  • 一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开
  • 形参是某种类型的指针或引用,指向的是常量对象和指向非常量对象的函数可以重载,此时的const是底层的
• const_cast和重载
  • const_cast在重载函数的情景中最有用const_cast
• 函数匹配：把函数调用与一组重载函数中的某一个关联起来。编译器首先将调用的实参与重载集合中每一个函数的形参进行比较,然后根据比较的结果决定到底调用哪个函数
• 在内层作用域中声明名字,将隐藏外层作用域中声明的同名实体
  • 在不同的作用域中无法重载函数名

1
2
3
4
5
6
7
8
9

const string &shorterString(const string &s1, const string &s2){
  return 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);
}

6.5 特殊用途语言特性

6.5.1 默认实参

• 调用含有默认实参的函数时,可以包含该实参,也可以省略该实参
• 默认实参初始化
  • 局部变量不能作为默认实参
  • 只要表达式的类型能转换成形参所需的类型,该表达式就能作为默认实参
  • 函数的后续声明只能为之前那些没有默认值的形参添加默认实参,而且该形参右侧的所有形参必须都有默认值
  • 用作默认实参的名字在函数声明所在的作用域内解析,名字的求值过程发生在函数调用时

6.5.2 内联函数和constexpr函数

• 内联函数：通常就是将它在每个调用点上内联地展开消除在运行时的开销
• 在返回类型前面加关键字inline就可以声明为内联函数
  • 一般来说,内联机制用于优化规模较小、流程直接、频繁调用的函数
• constexpr函数是指能用于常量表达式的函数
  • 定义constexpr函数：函数的返回类型及所有形参的类型都得是字面值类型,而且函数体中必须有且只有一条return语句
  • 执行该初始化任务时,编译器把对constexpr函数的调用替换成其结果值
  • 为了能在编译过程中随时展开,constexpr函数被隐式地指定为内联函数
  • constexpr函数体内也可以包含其他语句,只要这些语句在运行时不执行任何操作就行
    • 例如,constexpr函数中可以有空语句、类型别名以及using声明
  • constexpr函数不一定返回常量表达式
• 内联函数和constexpr函数经常放在头文件中

1
2
3
4
5
6
7

// 内联版本
inline const string &shorterString(const string &s1, const string &s2){
  return s1.size() <= s2.size() ? s1 : s2;
}

constexpr int new_sz(){return 42;}
constexpr int foo = new_sz; //正确

6.5.3 调试帮助

• 屏蔽调试代码的方法
  • assert
  • NDEBUG
• assert预处理宏
  • assert是一种预处理宏(预处理变量),类似于内联函数,定义在cassert文件中
  • 预处理名字由预处理器而非编译器管理,可以直接使用预处理名字而无须提供using声明
  • assert宏使用一个表达式作为它的条件: assert(expr);
    • 首先对expr求值,如果表达式为假,assert输出信息并终止程序的执行;为真,assert什么也不做
  • assert宏常用于检查“不能发生”的条件
• NDEBUG
  • assert的行为依赖于一个名为NDEBUG的预处理变量的状态
  • 定义NDEBUG能避免检查各种条件所需的运行时开销,当然此时根本就不会执行运行时检查
    • 可以把assert当成调试程序的一种辅助手段
  • 预处理器定义了对于程序调试很有用的名字
    • _ FILE _ 存放文件名的字符串字面值
    • _ LINE _ 存放当前行号的整型字面值
    • _ TIME _ 存放文件编译时间的字符串字面值
    • _ DATE _ 存放文件编译日期的字符串字面值
    • _ func _当前调试的函数的名字

1
2
3
4
5
6
7
8
9
10
11

// 使用#define语句定义NDEBUG从而关闭调试状态
$ CC -D NDEBUG main.c
// 等价于在main.c文件的一开始写#define NDEBUG

// 可以使用NDEBUG编写自己的条件调试代码
// 如果NDEBUG未定义,将执行#ifndef和#endif之间的代码;如果定义了NDEBUG,这些代码将被忽略掉
void print(const int ia[], size_t size){
  #ifndef NDEBUG
    cerr << __func__ << size << endl;
  #endif
}

6.6 函数匹配

• 函数匹配步骤
  • 第一步是选定本次调用对应的重载函数集,集合中的函数称为候选函数
    • 候选函数具备两个特征：一是与被调用的函数同名,二是其声明在调用点可见
  • 第二步考察本次调用提供的实参,然后从候选函数中选出能被这组实参调用的函数,这些新选出的函数称为可行函数
    • 可行函数也有两个特征：一是其形参数量与本次调用提供的实参数量相等,二是每个实参的类型与对应的形参类型相同,或者能转换成形参的类型
    • 如果函数含有默认实参,则在调用该函数时传入的实参数量可能少于它实际使用的实参数量
  • 第三步是从可行函数中选择与本次调用最匹配的函数
  • 如果有且只有一个函数满足下列条件,则匹配成功：
    • 该函数每个实参的匹配都不劣于其他可行函数需要的匹配
    • 至少有一个实参的匹配优于其他可行函数提供的匹配

6.6.1 实参类型转换

• 为了确定最佳匹配,编译器将实参类型到形参类型的转换划分成几个等级,具体排序如下所示：
  1. 精确匹配,包括以下情况：
     • 实参类型和形参类型相同。
     • 实参从数组类型或函数类型转换成对应的指针类型
     • 向实参添加顶层const或者从实参中删除顶层const。
  2. 通过const转换实现的匹配
  3. 通过类型提升实现的匹配
  4. 通过算术类型转换或指针转换实现的匹配

6.7 函数指针

• 函数指针指向的是函数而非对象
  • 函数指针指向某种特定类型,函数的类型由它的返回类型和形参类型共同决定,与函数名无关
  • 声明函数指针：在函数声明中,只需要用指针替换函数名即可

1
2
3
4
5

// 定义pf函数指针
bool (*pf)(const string &, const string &); //未初始化
// *pf两端的括号必不可少
// 如果不写这对括号,则pf是一个返回值为bool指针的函数
bool *pf(const string &, const string &); //未初始化

• 使用函数指针
  • 把函数名作为一个值使用时,该函数自动地转换成指针
  • 直接使用指向函数的指针调用该函数,无须提前解引用指针
  • 可以为函数指针赋一个nullptr或者值为0的整型常量表达式,表示该指针没有指向任何一个函数
• 重载函数指针：如果定义了指向重载函数的指针,编译器通过指针类型决定选用哪个函数,指针类型必须与重载函数中的某一个精确匹配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// pf函数指针
pf = lengthCompare;   //pf指向lengthCompare函数
pf = &lengthCompare;    //等价赋值语句

bool b1 = pf("hello","goodbye");    //调用lengthCompare函数

string::size_type sumLength(const string&,const string&);
bool cstringCompare(const char*, const char*);
pf = 0; //正确,不指向任何函数
pf = sumLength; //错误,返回类型不匹配

pf = cstringCompare;  //错误,形参类型不匹配
pf = lengthCompare; //正确

// 重载函数指针
void ff(int*);
void ff(unsigned int);

void (*pf1)(unsigned int) = ff;   //pf1指向ff(unsigned)

• 函数指针形参
  • 和数组类似,虽然不能定义函数类型的形参,但形参可以是指向函数的指针
  • 形参看起来是函数类型,但实际上当作指针使用
    • 直接把函数作为实参,会自动转换成指针
• 返回指向函数的指针
  • 必须把返回类型写出指针形式,编译器不会自动地将函数返回类型当成对应的指针类型处理
  • 要想声明一个返回函数指针的函数,最简单的办法是使用类型别名
    • 和函数类型的形参不一样,返回类型不会自动地转换成指针;需要显式地将返回类型指定为指针
  • 可以使用尾置返回类型的方式声明一个返回函数指针的函数
• 将auto和decltype用于函数指针类型
  • 如果明确知道返回的函数是哪一个,就能使用decltype简化书写函数指针返回类型的过程
  • 将decltype作用于某个函数时,返回函数类型而非指针类型
    • 需要显式地加上*以表明我们需要返回指针,而非函数本身

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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);

// 返回指向函数的指针
using F = int(int *, int); //F是函数类型,不是指针
using PF = (int*)(int *,int); //PF是指针类型

PF f1(int); //正确;PF是指向函数的指针,f1返回指向函数的指针
F *f1(int);   //正确;显式指定返回类型是指向函数的指针

//等价声明
int (*f1(int))(int*,int);
//照由内向外的顺序阅读这条声明语句：我们看到f1有形参列表,所以f1是个函数
// f1前面有*,所以f1返回一个指针;进一步观察发现,指针的类型本身也包含形参列表,因此指针指向函数,该函数的返回类型是int

auto f1(int) -> int (*) (int*,int);

7 类

• 类的基本思想是数据抽象和封装
  • 数据抽象是一种依赖于接口和实现分离的编程技术
    • 类的接口包括用户所能执行的操作;
    • 类的实现则包括类的数据成员,负责接口实现的函数体以及定义类所需的各种私有函数
  • 封装实现了类的接口和实现的分离
    • 封装后的类隐藏了它的实现细节

7.1 定义抽象数据类型

7.1.1 定义改进的类

• 成员函数的声明必须在类的内部,定义既可以在类的内部也可以在类的外部
  • 定义在类内部的函数是隐式的inline函数
• 作为接口组成部分的非成员函数,定义和声明在类的外部
• this参数
  • 成员函数通过一个名为this的额外的隐式参数来访问调用它的哪个对象
  • this是一个常量指针,总是指向这个对象
  • 在成员函数内部,可以直接使用调用该函数的对象的成员,而无须成员访问运算符,
    • 因为this所指的正是这个对象,任何对类成员的直接访问都被看作this的隐式引用
• 引入const成员函数(常量成员函数)
  • 默认情况下,this的类型是指向类类型非常量版本的指针常量
    • 因此在默认情况下,不能把this绑定在常量对象上,不能在常量对象上调用普通的成员函数
  • 修改为指向常量的指针常量,需要在参数列表后添加const关键词,表示this是指向常量的指针常量
  • 常量对象,以及常量对象的引用或指针都只能调用常量成员函数
• 在类的外部定义成员函数,定义需要与声明匹配,类外部定义的成员的名字必须包含所属的类名,使用::作用符
• 定义返回this对象的函数
  • 函数的返回类型为类,return语句返回*this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 常量成员函数
std::string isbn() const
{
  return bookNo;
}

// 等价于
std::string Sales_data::isbn(const Sales_data *const this)
{
  return this->isbn;
}

// 定义返回this对象的函数
Sales_data& Sales_data::combine(const Sales_data &rhs){
  units_sold += rhs.units_dold;
  revenue += tho.revenue;
  return *this;
}

total.combine(trans);   // 更新total的值
// total的地址被绑定到隐式的this参数上,而rhs绑定到了trans上。
// 效果等同于求total.units_sold和trans.unit_sold的和,然后把结果保存到total.units_sold中

// 无须使用隐式的this指针访问函数调用者的某个具体成员,而是需要把调用函数的对象当成一个整体来访问：
return *this;
// 其中,return语句解引用this指针以获得执行该函数的对象,调用返回total的引用

7.1.3 定义类相关的非成员函数

• 如果函数在概念上属于类但是不定义在类中,则它一般应与类声明(而非定义)在同一个头文件内
  • 在这种方式下,用户使用接口的任何部分都只需要引入一个文件

7.1.4 构造函数

• 构造函数：初始化类对象的数据成员,无论何时只要类的对象被创建,就会执行函数
  • 构造函数的名字和类名相同,但构造函数没有返回类型
  • 构造函数不能声明为const,直到构造函数完成初始化过程,对象才能真正取得其常量属性,构造函数在const对象的构造过程中可以向其写值
• 合成的默认构造函数
  • 类通过一个特殊的构造函数来控制默认初始化过程
  • 如果存在类内的初始值,用它来初始化成员,否则默认初始化该成员
• 不能合成默认构造函数的情况
  • 类没有声明任何构造函数,编译器会自动合成默认构造函数
  • 类包含有内置类型或复合类型的成员,则只有当这些成员全都被赋予了类内的初始值,这个类才适合使用默认的构造函数
• =default
  • 在C++11中,需要默认的行为,可以在参数列表后写上 =default 来要求编译器生成构造函数
  • =default 既可以和声明一起出现在类的内部(默认构造函数为内联函数),可以作为定义出现在类外部
• 构造函数初始化列表
  • 构造函数冒号后的部分为构造初始化列表,构造函数初始值是成员名字的一个列表,每个名字后面紧跟着括号括起来的成员初始值,不同成员的初始化通过逗号分隔开
  • 负责新创建的对象的一个或几个数据成员赋初值
• 类的外部定义构造函数：使用 类名::类名 的结构

7.1.5 拷贝,赋值和析构

• 编译器可以合成拷贝,赋值和析构函数,但生成的版本可能无法正常工作

7.2 访问控制与封装

• 使用访问说明符加强类的封装性
  • 定义在public说明符之后的成员在整个程序内可被访问
    • public成员定义类的接口
  • 定义在private说明符之后的成员可被类的成员函数防备,但不能在使用类的代码访问
    • private部分封装了类的实现细节
• 使用class或struct关键字
  • 使用class关键字定义类,成员默认是private的
  • 使用struct关键字定义类,成员默认是public的

7.2.1 友元

• 友元：类可以允许其他类或者函数访问它的非共有成员,方法是令其他类或函数成为它的友元
  • 只需要增加一条以friend关键字开始的函数声明语句即可
  • 友元声明只能出现在类定义的内部,但类出现的具体位置不限
  • 友元不是类的成员也不受它所在区域访问控制级别的约束,最好再类定义开始或结束前的位置声明友元
• 封装的好处
  • 确保用户代码不会无意间破坏封装对象的状态
  • 被封装的类的具体实现细节可以随时改变,而无须调整用户级别的代码
  • 防止由于用户的原因造成数据被破坏
• 友元的声明
  • 如果希望类的用户能够调用某个友元函数,那么就必须在友元声明之外再专门对函数进行一次声明
    • 为了使友元对类的用户可见,通常把友元的声明与类本身放置在同一个头文件中(类的外部)
    • 需要调用的友元函数,在类的外部需再次声明

7.3 类的其他特性

7.3.1 类成员再探

• 类内部的成员函数自动是inline的
  • 可以在类内部把inline显式声明,但不推荐;最好在类外部定义的地方声明inline
• 成员函数可以被重载
• 可变数据成员
  • 使用mutable关键字
  • 一个可变数据成员永远不会是const,即使是const对象的成员
  • 一个const成员函数可以改变一个可变成员的值
• 在C++11中将默认值声明成类内初始值,可以在默认初始化时拥有默认初始值
  • 类内初始值必须使用=的初始化形式或者花括号括起来的直接初始化形式

1
2
3
4
5
6
7
8
9
10
11
12
13

class Screen{
  public:
    void some_member() const;
  private:
    mutable size_t access_ctr;  //即使在const对象内也能被修改
}

void Screen::some_member() const
{
  ++access_ctr;
}
// 尽管some_member是一个const成员函数,它仍然能够改变access_ctr的值
// 该成员是个可变成员,因此任何成员函数,包括const函数在内都能改变它的值

7.3.2 返回*this的成员函数

• 定义返回this对象的函数
• 从const成员函数返回*this
  • 一个const成员函数如果以引用的形式返回*this,那返回类型将是常量引用
  • 函数声明中返回的是const类型的类引用
• 基于const的重载
  • 区分成员函数是否是const可以对函数进行重载
  • 非常量版本的函数对常量对象是不可用的,需要在一个常量对象上调用const成员函数;但可以在非常量对象上调用const成员函数,但建议显式匹配

7.3.3 类类型

• 每个类定义了唯一的类型,即使两个类的成员列表完全一致,也是不同的类型
• 可以把类名作为类型的名字使用,从而直接指向类类型
  • 或者,也可以把类名跟在关键字class或struct后面
• 类的声明：声明类而暂时不定义
  • class 类名; 声明称为前向声明,向程序中引入类,但声明类之后类是一个不完全类型,不清楚包括哪些成员

7.3.4 友元再探

• 类之间的友元关系
  • 友元类的成员函数可以访问此类包括非公有成员在内的所有成员
  • 友元关系不存在传递性,每个类负责控制自己的友元类或友元函数
• 令成员函数作为友元
  • 当把一个成员函数声明为友元时,必须知名成员函数属于哪个类
• 函数重载和友元
  • 一个类想把一组重载函数声明为它的友元,需要对这组函数中的每一个分别声明
• 友元声明和作用域
  • 类和非成员函数的声明不是必须在友元声明之前
  • 在类的内部定义该函数,必须在类的外部提供相应的声明从而使得函数可见
    • 即使仅仅是用声明友元的类的成员调用该友元函数,它也必须是被声明过的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Screen{
  // windos_mgr::clear必须在Screen类之前被声明
  friend void Window_mgr::clear(ScreenIndex);
  // Screen类的剩余部分
}
// 必须按照如下方式设计程序：
// · 首先定义Window_mgr类,其中声明clear函数,但是不能定义它。在clear使用Screen的成员之前必须先声明Screen
// · 接下来定义Screen,包括对于clear的友元声明
// · 最后定义clear,此时它才可以使用Screen的成员

struct X{
  friend void f(){}
  X(){f();}
  void g();
  void h();
}

void X::g(){return f();}  //错误f()未声明
void f();
void X::h(){return f();}  //正确

7.4 类的作用域

• 在类的作用域之外,普通的数据和函数成员只能由对象,引用或指针使用成员访问运算符进行访问
• 对于类类型成员使用作用域运算符::来访问
• 当成员函数定义在类的外部时,返回类型中使用的名字都位于类的作用域之外时,返回类型必须指明它是哪个类的成员

7.4.1 名字查找与类的作用域

• 内层作用域可以重新定义外层作用域中的名字,即使该名字已经在内层作用域中使用过
• 在类中,如果成员使用了外层作用域中的某个名字,而该名字代表一种类型,则类不能在之后重新定义该名字
• 在类中,成员函数中定义的成员会隐藏类中的同名成员,但可以使用类名或this指针强制访问成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

typedef double Money;
class Accout{
  public:
    Money balance(){
      return bal;
    }
  private:
    typedef double Money; //错误,不能重新定义
}

class Screen{
  public:
    typedef std::string::size_type pos;
    void dummy_fcn(pos height){
      cursor = width * height;   //是那个参数
    }
  private:
    pos cursor = 0;
    pos height = 0, width = 0;
}

// 不建议的写法,成员函数中的名字不应该隐藏同名的成员
void Screen::dummy_fcn(pos height){
    cursor = width * this->height;   //成员height
    // 或
    cursor = width * Screen::height;
  }

// 建议的写法：不要把成员名字作为参数或其他局部变量使用
void Screen::dummy_fcn(pos ht){
  cursor = width * height;   //成员height
}

// 不建议的写法,不应该隐藏外层作用域中可能用到的名字
void Screen::dummy_fcn(pos height){
  cursor = width * ::height;   //全局的height
}

7.5 构造函数再探

7.5.1 构造函数初始值列表

• 初始化const或引用类型的唯一机会就是通过构造函数初始值
  • 如果成员是const,引用,或者属于某种未提供默认构造函数的类类型,我们必须通过构造函数初始值列表为这些成员提供初值
• 建议：使用构造函数初始值
  • 在很多类中,初始化和赋值的区别事关底层效率问题：前者直接初始化数据成员,后者则先初始化再赋值
  • 除了效率问题外更重要的是,一些数据成员必须被初始化
• 构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序
  • 但一个成员是用于另一个成员初始化时,位置关系较为重要
  • 最好令构造函数初始值的顺序与成员声明的顺序保持一致。而且若可能的话,尽量避免使用某些成员初始化其他成员

1
2
3
4
5
6
7
8
9
10
11
12

class ConstRef{
  public:
    ConstRef(int ii);
  private:
    int i;
    const int ci;
    int &ri;
}

// 构造函数体一开始执行,初始化就完成了
// 显式初始化引用和const成员
ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(i){}

7.5.2 委托构造函数

• C++11中扩展了构造函数初始值的功能,可以定义委托构造函数
  • 委托构造函数使用它所属类的其他构造函数执行自己的初始化过程,它把自己的一些职责委托给了其他构造函数
  • 委托构造函数具有成员初始化列表和一个函数体,成员初始化列表只有类名本身一个入口
  • 成员初始值:类名后面紧跟着圆括号形成的参数列表,参数列表必须和类中另外一个构造函数匹配
  • 先执行该构造函数的函数体代码再执行被委托构造函数的函数体

1
2
3
4
5
6
7
8
9

class Sales_data{
  public:
    Sales_data(std::string s, unsigned cnt, double price):
      bookNo(s), units_sold(cnt), revenue(cnt*price){}
    // 其他构造函数委托给另一个构造函数
    Sales_data() : Sales_data("",0,0){}
    Sales_data(std::string s) : Sales_data(s,0,0){}
    Sales_data(std::istream &is) : Sales_data{read(is,*this);}
};

7.5.3 默认构造函数的作用

• 当对象被默认初始化或值初始化时自动执行默认构造函数
• 默认初始化在以下情况下发生：
  • 当我们在块作用域内不使用任何初始值定义一个非静态变量或者数组时
  • 当一个类本身含有类类型的成员且使用合成的默认构造函数
  • 当类类型的成员没有在构造函数初始值列表中显式地初始化时显式初始化
• 值初始化在以下情况下发生
  • 在数组初始化的过程中如果我们提供的初始值数量少于数组的大小时
  • 当我们不使用初始值定义一个局部静态变量时,局部对象
  • 当我们通过书写形如T( )的表达式显式地请求值初始化时,其中T是类型名(vector的一个构造函数只接受一个实参用于说明vector大小,它就是使用一个这种形式的实参来对它的元素初始化器进行值初始化)

7.5.4 隐式的类类型转换

• 类定义隐式转换规则:如果构造函数只接受一个实参,则它实际上定义了转换为此类类型的隐式转换机制,这种构造函数称作转换构造函数
  • 在需要该类对象的地方,可以使用其他可转换的对象类型作为替代
  • 只允许一步类型转换,编译器指挥自动地执行一步类型转换
• 可以将构造函数声明为explicit抑制构造函数定义的隐式转换
  • explicit只对一个实参的构造函数有效
• explicit构造函数只能用于直接初始化
  • 发生隐式转换的一种情况是当执行拷贝形式(=)的初始化时
  • 以直接初始化的形式可以使用explicit构造函数抑制自动转换

1
2
3
4
5
6
7
8
9
10
11
12

string null_book = "9-999-99999-9";
// 构造一个临时的Sales_data对象
item.combine(null_book);

// 错误,两步转换
item.combine("9-999-99999-9");
// 正确
item.combine(string("9-999-99999-9"));

// 显式构造
item.combine(Sales_data(null_book));
item.combine(static_cast<Sales_data>(cin));

7.5.5 聚合类

• 聚合类使得用户可以直接访问其成员,并且具有特殊的初始化语法形式
• 当一个类满足如下条件时,为聚合的：
  • 所有成员都是public的
  • 没有定义任何构造函数
  • 没有类内初始值,参考
  • 没有基类,也没有virtual函数
• 可以使用花括号的成员初始值列表初始化聚合类的数据成员
  • 初始值的列表必须和声明的顺序一致
  • 初始值列表中的元素个数少于类的成员数量,靠后的成员被值初始化

1
2
3
4
5
6

struct Data{
  int ival;
  string s;
};

Data vall = {0, "Anna};

7.5.6 字面值常量类

• constexpr,其中提到constexpr函数的参数和返回值都必须是字面值类型
• 字面值类型的类可能含有constexpr函数成员
  • 成员必须符合constexpr函数的所有要求,是隐式const的
• 数据成员都是字面值类型的聚合类是字面值常量类
• 如果一个类不是聚合类,但符合下述要求,则也是一个字面值常量类：
  • 数据成员都必须是字面值类型
  • 类必须至少含有一个constexpr构造函数
  • 如果一个数据成员含有类内初始值,则内置类型成员的初始值必须是一条常量表达式;或者如果成员属于某种类类型,则初始值必须使用成员自己的constexpr构造函数
  • 类必须使用析构函数的默认定义
• constexpr构造函数
  • 字面值常量类的构造函数可以是constexpr函数
  • constexpr构造函数可以声明成=default的形式(或者是删除函数的形式)
    • 否则,constexpr构造函数就必须既符合构造函数的要求(意味着不能包含返回语句),又符合constexpr函数的要求(意味着它能拥有的唯一可执行语句就是返回语句
  • 由上述可知,constexpr构造函数体一般来说应该是空的
  • constexpr构造函数必须初始化所有数据成员,初始值或者使用constexpr构造函数,或者是一条常量表达式
    • constexpr构造函数用于生成constexpr对象以及constexpr函数的参数或返回类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 字面值常量类
class Debug{
  public:
    constexpr Debug(bool b = true): hw(b),io(b),other(b){}
    constexpr Debug(bool h, bool i, bool o): hw(h),io(i),other(o){}
    constexpr bool any(){return hw||io||other;}
    void set_io(bool b){io=b;}
    void set_hw(bool b){hw=b;}
    void set_other(bool b){hw=b;}
  private:
    bool hw;
    bool io;
    bool other;
}

// constexpr构造函数用于生成constexpr对象以及constexpr函数的参数或返回类型
constexpr Debug io_sub(false,true,false); //调试io
// 等价于
if(io_sub.any())
  cerr << "print error" <<endl;

constexpr Debug prod(false);  //无调试
// 等价于
if(prod.any())
  cerr << "print error" <<endl;

7.6 类的静态成员

• 声明静态成员
  • 声明成员为static使得其与类关联在一起
  • 可以是public或private,可以是常量,引用,指针,类类型等
• 类的静态成员存在于任何对象之外,对象中不包含任何与静态数据成员有关的数据
  • 静态成员函数不会与任何对象绑定在一起,不包含this指针
  • 静态成员函数不能声明称const,且不能在静态成员函数中使用this指针
• 通过**作用域运算符::**访问静态成员,可以使用类的对象,引用或指针来访问静态成员。
  • 成员函数不用通过作用域运算符就可以直接访问静态成员
• 定义静态成员
  • 可以在类的内部或外部定义静态成员函数
  • 在类的外部定义静态成员时,不能重复static关键字,该static关键字只能出现在类内部的声明中
  • 静态数据成员不属于类的任何一个对象,不是由类的构造函数初始化的,因此需要在类的外部定义和初始化每个静态成员,静态数据只能定义一次,且存在于程序的整个声明周期
• 静态成员的类内初始化
  • 通常情况下,类的静态成员不应该在类的内部初始化
  • 然而,可以为静态成员提供const整数类型的类内初始值,不过要求静态成员必须是字面值常量类型的constexpr
  • 即使一个常量静态数据成员在类内部被初始化了,通常情况下也应该在类的外部定义一下该成员
• 静态数据可以作为默认实参,非静态数据成员不能作为默认实参,因为它的值本身属于对象的一部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 定义并初始化一个静态成员
double Account::interestRate = initRate();
// 该对象是类Account的静态成员,其类型是double
// 从类名开始,这条定义语句的剩余部分就都位于类的作用域之内了
// 因此,可以直接使用initRate函数
// 注意,虽然initRate是私有的,也能用它初始化interestRate

// 静态成员的类内初始化
class Account{
  public:
    static double rate() {return interestRate;}
    static void rate(double);
  private:
    static constexpr int period = 30; //常量表达式
    double daily_tbl[period];
}

8 IO库

• io库的基础设施
  • istream
  • ostream
  • cin
  • cout
  • cerr
  • >>
  • <<
  • getline()

8.1 IO类

• 宽字符版本的类型和函数的名字以w开始
  • wcin,wcout和wcerr对应cin,cout,cerr
• IO类型间的关系
  • 概念上,设备类型和字符大小都不会影响要执行的IO操作
  • 标准库使我们可以忽略不同类型的流之间的差异,是通过继承机制实现的

8.1.1 IO对象无拷贝或赋值

• 不能拷贝或对IO对象赋值,因此不能将形参或返回类型设置为流类型
  • 进行IO操作的函数通常以引用方式传递和返回流,读写一个IO对象会改变其状态,传递和返回引用不能是const

8.1.2 条件状态

• IO库定义了一个与机器无关的iostate类型,提供了表达流状态的完整功能,这个类型作为一个位集合使用
  • IO库定义了4个iostate类型的constexpr值,表示特定的位状态
  • badbit表示系统级错误,通常情况下,一旦badbit被置位,流就无法再使用了
  • 在发生可恢复错误后,failbit被置位,通常是可以修正的,流还可以继续使用
  • 如果到达文件结束位置,eofbit和failbit都会被置位
  • goodbit的值为0,表示流未发生错误
• 管理条件状态
  • 流对象的rdstate成员返回一个iostate值,对应流的当前状态

1
2
3
4
5
6
7
8
9

// 记住cin当前状态
// clear不接受参数的版本清除(复位)所有错误标志位
auto old_state = cin.rdstate();
cin.clear();
process_input(cin); //使用cin
cin.setstate(old_state);  //置位会原有状态
// 带参数的clear版本接受一个iostate值,表示流的新状态
// 复位failbit和badbit,其他位保持不变
cin.clear(cin.rdstate & ~cin.failbit & ~cin.badbit);

8.1.3 管理输出缓冲

• 每个输出流都管理一个缓冲区,用来保存程序读写的数据
• 导致缓冲刷新的原因
  • 程序正常结束,作为main函数的return操作的一部分,缓冲刷新被执行
  • 缓冲区满时,需要刷新缓冲,而后新的数据才能继续写入缓冲区
  • 可以使用操纵符如endl来显式刷新缓冲区
  • 在每个输出操作之后,可以用操纵符unitbuf设置流的内部状态,来清空缓冲区
    • 默认情况下,对cerr是设置unitbuf的,因此写到cerr的内容都是立即刷新的
  • 一个输出流可能被关联到另一个流。在这种情况下,当读写被关联的流时,关联到的流的缓冲区会被刷新
    • 默认情况下,cin和cerr都关联到cout。因此,读cin或写cerr都会导致cout的缓冲区被刷新
• 刷新输出缓冲区
  • endl
  • IO库中的flush和ends
    • flush刷新缓冲区,但不输出任何额外的字符
    • ends向缓冲区插入一个空字符,然后刷新缓冲区
• unitbu操作符
  • 可控制不每次输出操作后都刷新缓冲区
  • nounitbu重置流,使其恢复正常使用
• 程序崩溃,输出缓冲区不会被刷新
• 关联输入和输出
  • 当一个输入流被关联到一个输出流时,任何试图从输入流读取数据的操作都会先刷新关联的输出流
  • 标准库将cout和cin关联在一起
  • tie有两个重载的版本
    • 不带参数：返回指向输出流的指针(如果本对象当前关联到一个输出流,则返回的就是指向这个流的指针,如果对象未关联到流,则返回空指针)
    • 接受一个指向ostream的指针：将自己关联到此ostream( x.tie(&o)将x关联到输出流o)

1
2
3
4
5
6
7
8
9
10
11
12

cout<<"hi"<<endl;
cout<<"hi"<<flush;
cout<<"hi"<<ends;

cout << unitbuf;
cout << nounitbuf;

cin.tie(&cout);

ostream *old_tie = cin.tie(nullptr);
cin.tie(&cerr);
cin.tie(old_tie);

8.2 文件输入输出

• 头文件fstream定义了三个类型来支持文件IO：
  • ifstream从一个给定文件读取数据
  • ofstream向一个给定文件写入数据
  • fstream可以读写给定文件
• 使用IO运算符读写文件,可以用getline从一个ifstream读取数据

8.2.1 使用文件流对象

• 想要读写一个文件时,可以定义一个文件流对象,并将对象与文件关联起来,每个文件流类都定义了一个名为open的成员函数,完成一些系统相关的操作,用来定位给定的文件,并视情况打开为读或写模式
• 用fstream代替iostream&
  • 在要求使用基类型对象的地方,可以用继承类型的对象来替代
  • 接受一个iostream类型引用(或指针)参数的函数,可以用一个对应的fstream(或sstream)类型来调用
    • 如果有一个函数接受一个ostream&参数,在调用这个函数时,可以传递给它一个ofstream对象,对istream&和ifstream也是类似的
• 成员函数open和close
  • 定义一个文件流对下昂,随后可以调用open将文件关联起来(调用open失败,failbit会被置位)
• 自动析构：当一个fstream对象被销毁时,close会自动被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

ifstream in(ifile); //构建一个ifstream并代开给定文件
ofstream out; //输出文件流未关联到任何文件

ifstream input(argv[1]);  //打开销售记录文件
ofstream output(argv[2]);
Sales_data total;
if(read(input,total)){
  Sales_data trans;
  while(read(input,trans)){
    if(total.isbn()==trans.isbn())
      total.combine(trans);
    else{
      print(output,total)<<endl;
      total = trans;
    }
  }
  print(out,total) <<endl;
} else
  cerr<<"No data?!"<<endl;

// open文件流
ifstream in(ifile);
ofstream out;
out.open(ifile + ".copy");

if(out) //检测open是否成功

in.close;
in.open(ifile + "2");

8.2.2 文件模式

• 只可以对ofstream或fstream对象设定out模式
• 只可以对ifstream或fstream对象设定in模式
• 只有当out也被设定时才可设定trunc模式
• 只要trunc没被设定,就可以设定app模式。在app模式下,即使没有显式指定out模式,文件也总是以输出方式被打开
• 默认情况下,即使我们没有指定trunc,以out模式打开的文件也会被截断。为了保留以out模式打开的文件的内容,我们必须同时指定app模式,这样只会将数据追加写到文件末尾;或者同时指定in模式,即打开文件同时进行读写操作
• ate和binary模式可用于任何类型的文件流对象,且可以与其他任何文件模式组合使用
• 每个文件流类型都定义了一个默认的文件模式,当我们未指定文件模式时,就使用此默认模
  • 与ifstream关联的文件默认以in模式打开
  • 与ofstream关联的文件默认以out模式打开
  • 与fstream关联的文件默认以in和out模式打开
• 在每次打开文件时,都要设置文件模式,可能是显式地设置,也可能是隐式地设置。当程序未指定模式时,就使用默认值

8.3 string流

• istringstream从string读取数据
• ostringstream向string写入数据
• stringstream既可从string读数据也可向string写数据

• 使用istringstream：当某些工作是对整行文本进行处理,而其他一些工作是处理行内的单个单词时,通常可以使用istringstream
• 使用ostringstream：当逐步构造输出,希望最后一起打印时,ostringstream是很有用的

9 序容器

• 顺序容器为程序员提供了控制元素存储和访问顺序的能力

9.1 顺序容器概述

• 除了固定大小的array外,其他容器都提供高效,灵活的内存管理
  • 可以添加和删除元素,扩张和收缩容器的大小
  • string和vector将元素保存在连续的内存空间中
    • 可以由元素的下标来计算其地址是非常快速的,两个容器的中间位置添加和删除元素会非常耗时
  • list和forward_list两个容器的设计目的是令容器任何位置的添加和删除都很快捷,但不支持元素的随机访问(为了访问元素只能遍历整个容器),其额外内存开销也很大
  • deque中间的位置添加或删除元素的代价很高,但在两端添加或删除元素很快,与list和forward_list添加删除元素的速度相当
• C++11中新添加的类型,forward_list和array
  • 与内置数组类似,array对象的大小是固定的
    • array不支持添加和删除元素以及改变容器大小的操作
  • forward_list的设计目标是达到与最好的手写的单向链表数据结构相当的性能
    • 因此forward_list没有size操作,因为保存或计算其大小就会比手写链表多出额外的开销
    • 对其他容器而言,size保证是一个快速的常量时间的操作
• 选择容器的基本原则
  • 除非你有很好的理由选择其他容器,否则应使用vector
  • 如果程序有很多小的元素,且空间的额外开销很重要,则不要使用list或forward_list
  • 如果程序要求随机访问元素,应使用vector或deque
  • 如果程序要求在容器的中间插入或删除元素,应使用list或forward_list
  • 如果程序需要在头尾位置插入或删除元素,但不会在中间位置进行插入或删除操作,则使用deque
  • 如果程序只有在读取输入时才需要在容器中间位置插入元素,随后需要随机访问元素,则
    • 首先,确定是否真的需要在容器中间位置添加元素。当处理输入数据时,通常可以很容易地向vector追加数据,然后再调用标准库的sort函数来重排容器中的元素,从而避免在中间位置添加元素
    • 如果必须在中间位置插入元素,考虑在输入阶段使用list,一旦输入完成,将list中的内容拷贝到一个vector中

9.2 容器库概览

• 每个容器都定义在一个头文件中,文件名与类型名相同,容器均为模板类
• 对容器可保存的元素类型的限制
  • 顺序容器可以保存任意类型的元素,特别是,可以定义一个容器,其元素类型是另一个容器
  • 可以为不支持特定操作需求的类型定义容器(但只能使用那些没有特殊需求的容器操作)

9.2.1 迭代器

• 与容器一样,迭代器有公共的接口：迭代器提供的操作的实现方式都是相同的
  • forward_list迭代器不支持递减运算符
• 迭代器范围
  • 一个迭代器范围由一对迭代器表示,两个迭代器分别指向同一容器中的元素(begin,first)或者尾元素(end,last,尾元素的下一个元素)之间的元素
  • 元素范围为左闭合区间
• 构成范围的迭代器的要求
  • 两个迭代器begin和end构成一个迭代器
    • 指向同一容器的元素,或者是容器最后一个元素之后的位置,且可以通过递增begin到达end

9.2.3 begin和end成员

• begin和end操作生成指向容器第一个元素和尾元素之后位置的迭代器,形成一个包含容器内所有元素的迭代器范围
• 带r的反向迭代器
• 带c的返回const迭代器的版本
  • C++11新引入的,用于支持auto与begin和end函数相结合
  • 当不需要写访问时,应该使用cbegin和cend

9.2.4 容器定义和初始化

• 将一个容器初始化为另一个容器的拷贝
  • 可以直接拷贝整个容器
    • 两个容器的类型及其元素类型必须匹配
  • 拷贝由一个迭代器对指定元素范围
    • 新容器和原容器中元素类型可以不同,只要能将拷贝元素转换为要初始化的容器的元素类型即可
    • 构造函数接受两个迭代器参数,为第一个元素和尾元素之后的元素
• 列表初始化
  • C++11中可以对容器进行列表初始化,显式指定容器中每个元素的值
• 与顺序容器大小相关的构造函数
  • 接受一个容器大小和一个可选的元素初始值
  • 只有顺序容器的构造函数才接受大小参数,关联容器并不支持
• 标准库array由固定大小
  • 定义array时不仅要指定元素类型,也要指定大小
  • 不支持普通的容器构造函数,一个默认构造的array非空,包含于大小一样多的默认初始化的元素

1
2
3
4
5
6
7
8
9
10
11
12

list<string> authors = {"Milton","Shakespeare","Austen"};
vector<const char*> articles = {"a","an","the"};

list<string> list2(authors);    //正确
deque<string> authList(authors);  //错误,容器类型不匹配
forward_list<string> words(articles.begin(),articles.end());  //正确,可以将const char*元素转换为string

//拷贝元素,直到(不包括)it指向的元素
deque<string> authList(authors.begin(),it);

array<int,42>   //保存42个int的数组
array<int,10>::size_type i;   //数组类型包括元素类型和大小

9.2.5 赋值和swap

• 赋值相关操作会导致指向坐标容器内部的迭代器,引用和指针失效
• swap会将容器内容交换,不会导致指向容器的迭代器,引用和指针失效(容器类型为array和string除外)
• 使用assign(仅顺序容器)
  • 允许从一个不同但相容的类型赋值,或者从容器的一个子序列赋值
  • 由于其旧元素被替换,因此传递给assign的迭代器不能指向调用assign的容器
• 使用swap
  • 除array外,swap不对任何元素进行拷贝、删除或插入操作,因此可以保证在常数时间内完成

9.2.7 关系运算符

• 每个容器类型都支持相等运算符
• 除了无序关联容器外的所有容器都支持关系运算符
• 比较两个容器实际上是进行元素的逐对比较
  • 如果两个容器具有相同大小且所有元素都两两对应相等,则这两个容器相等;否则两个容器不等
  • 如果两个容器大小不同,但较小容器中每个元素都等于较大容器中的对应元素,则较小容器小于较大容器
  • 如果两个容器都不是另一个容器的前缀子序列,则它们的比较结果取决于第一个不相等的元素的比较结果
• 只有当其元素类型也定义了相应的比较运算符时,才可以使用关系运算符来比较两个容器
  • 容器的相等运算符实际上是使用元素的==运算符实现比较的,而其他关系运算符是使用元素的<运算符

9.3 顺序容器操作

9.3.1 向顺序容器添加元素

• 除array外,所有的标准库容器提供灵活的内存管理,在运行时可以动态添加或删除元素来改变容器大小
  • forward_list有自己版本的insert和emplace
  • forward_list不支持push_back和emplace_back
  • vector和string不支持push_front和emplace_front

• 向一个vector,string或deque插入元素会使所有指向容器的迭代器,引用和指针失效
• 使用push_back
  • 除了array和forward_list之外,每个顺序容器都支持push_back
  • 当用一个对象来初始化容器时,或将一个对象插入到容器中时,实际上放入到容器中的是对象值的一个拷贝,而不是对象本身
• 使用push_front
  • list,forward_list和deque还支持push_front,将元素插入到容器头部
  • deque提供了随机访问元素的能力,且支持push_front,但vector具有随机访问的能力不支持push_front,插入元素非常耗时
• 在容器特定位置添加元素：insert成员,vector、deque、list和string都支持insert成员,但vector、deque和string插入元素耗时
• 插入范围内元素：insert带参数的版本
• 使用emplace操作
  • emplace_front、emplace和emplace_back,这些操作构造而不是拷贝元素,分别对应push_front、insert和push_back,允许将元素放置在容器头部、一个指定位置之前或容器尾部
  • 当调用push或insert成员函数时,将元素类型的对象传递给它们,这些对象被拷贝到容器中
  • 而当调用一个emplace成员函数时,则是将参数传递给元素类型的构造函数,emplace成员使用这些参数在容器管理的内存空间中直接构造元素(传递给emplace函数的参数必须和构造函数相匹配)

1
2
3
4
5
6

// 在c的末尾构造一个Sales_data对象
// 使用三个参数的Sales_data构造函数
c.emplace_back("978-0590353403",25,15.99);

// 创建一个临时的对象传递给push_back
c.push_back(Sales_data("978-0590353403",25,15.99));

9.3.2 访问元素

• 包括array在内的每个顺序容器都有一个front成员函数,而除forward_list之外的所有顺序容器都有一个back成员函数,分别返回首元素和尾元素的引用
  • 间接的方法：通过解引用begin返回的迭代器来获取首元素的引用,以及通过递减然后解引用end返回的迭代器来获得尾元素的引用
• at和下标操作只适用于string,vector,deque和array
  • back不适用于forward_list

• 访问成员函数返回的是引用：在容器中访问元素的成员函数返回的都是引用
  • 如果容器是一个const对象,则返回值是const的引用
  • 如果使用auto变量来保存函数的返回值,使用此变量来改变元素的值,应将变量定义为引用类型
• 安全的随机访问：使用at函数,类似下标运算符,若下标越界则抛出out_of_range异常

9.3.3 删除元素

• forward_list由特殊版本的erase
• forward_list不支持pop_back;vector和string不支持pop_front
• 删除deque中除首尾位置之外的任何元素都会使所有迭代器,引用和指针失效
  • 指向vector或string中删除点之后位置的迭代器,引用和指针都会失效
• 删除元素的成员函数并不检查其参数,在删除之前必须确保它们使存在的

9.3.4 特殊的forward_list操作

9.3.5 改变容器大小

• resize来增大或缩小容器(array不支持resize)
  • 如果当前大小大于所要求的大小,容器后部的元素会被删除
  • 如果当前大小小于新大小,会将新元素添加到容器后部

9.3.6 容器操作可能是迭代器失效

• 向容器中添加元素和从容器中删除元素的操作可能会使指向容器元素的指针、引用或迭代器失效。一个失效的指针、引用或迭代器将不再表示任何元素。使用失效的指针、引用或迭代器是一种严重的程序设计错误,很可能引起与使用未初始化指针一样的问题
• 在向容器添加元素后：
  • 如果容器是vector或string,且存储空间被重新分配,则指向容器的迭代器、指针和引用都会失效。如果存储空间未重新分配,指向插入位置之前的元素的迭代器、指针和引用仍有效,但指向插入位置之后元素的迭代器、指针和引用将会失效
  • 对于deque,插入到除首尾位置之外的任何位置都会导致迭代器、指针和引用失效。如果在首尾位置添加元素,迭代器会失效,但指向存在的元素的引用和指针不会失效
  • 对于list和forward_list,指向容器的迭代器(包括尾后迭代器和首前迭代器)、指针和引用仍有效。
    当我们从一个容器中删除元素后,指向被删除元素的迭代器、指针和引用会失效,这应该不会令人惊讶。毕竟,这些元素都已经被销毁了。当我们删除一个元素后：
    • 对于list和forward_list,指向容器其他位置的迭代器(包括尾后迭代器和首前迭代器)、引用和指针仍有效
    • 对于deque,如果在首尾之外的任何位置删除元素,那么指向被删除元素外其他元素的迭代器、引用或指针也会失效。如果是删除deque的尾元素,则尾后迭代器也会失效,但其他迭代器、引用和指针不受影响;如果是删除首元素,这些也不会受影响
    • 对于vector和string,指向被删元素之前元素的迭代器、引用和指针仍有效。注意：当我们删除元素时,尾后迭代器总是会失效
• 不要保存end返回的迭代器

9.4 vector对象是如何增长的

• vector和string的实现通常会分配比新的空间需求更大的内存空间,容器预留了这些文件作为备用,用来保存更多的新元素
  • 这种策略比每次添加新元素时重新分配内存空间高效,实际性能表现的足够好
• 管理容器的成员函数
  • vector和string类型提供了一些成员函数,允许我们与它的实现中内存分配部分互动
  • capacity操作告诉我们容器在不扩张内存空间的情况下可以容纳多少个元素
  • reserve操作允许我们通知容器它应该准备保存多少个元素
• shrink_to_fit只适用于vector,string和deque
  • capacity和reserve只适用于vector和string
  • reserve并不改变容器中元素的数量,它仅影响vector预先分配多大的内存空间
    • 如果需求大小大于当前容量,reserve至少分配与需求一样大的内存空间(可能更大)
    • 如果需求大小小于或等于当前容量,reserve什么也不做(且容器不会退回内存空间)
• 在C++11中,可以调用shrink_to_fit来要求deque、vector或string退回不需要的内存空间
  • 此函数指出不再需要任何多余的内存空间
  • 但具体的实现可以选择忽略此请求(调用shrink_to_fit也并不保证一定退回内存空间)

• capacity和size
  • size：指它已经保存的元素的数目
  • capacity：在不分配新的内存空间的前提下最多可以保存多少元素
• 每个vector实现都可以选择自己的内存分配策略
  • 但必须遵守的一条原则：只有当迫不得已时才可以分配新的内存空间
  • 只有在执行insert操作时size与capacity相等,或者调用resize或reserve时给定的大小超过当前capacity,vector才可能重新分配内存空间
• 虽然不同的实现可以采用不同的分配策略,但所有实现都应遵循一个原则：
  • 确保用push_back向vector添加元素的操作有高效率
  • 从技术角度说,就是通过在一个初始为空的vector上调用n次push_back来创建一个n个元素的vector,所花费的时间不能超过n的常数倍

9.5 额外的string操作

9.5.1 构造string的其他方法

容器定义和初始化方法

• 构造函数接受一个string或一个const char*参数
  • 传递一个string时可以给定一个下标来指出从哪里开始拷贝
  • 传递const char*时指针指向的数组必须以空字符结尾,拷贝操作时遇到空字符时停止
  • 传递构造函数一个计数值,数组就不必以空字符结尾
• substr操作
  • s.substr(pos,n) 返回一个string,包含s中从pos开始的n个字符的拷贝。pos的默认值为0.n的默认值为s.size()-pos,即拷贝从pos开始的所有字符

9.5.2 改变string的其他方法

9.5.3 string搜索操作

• 每个搜索操作都返回一个string::size_type值,表示匹配发生位置的下标
  • 如果搜索失败,则返回一个名为string::npos的static成员
  • 标准库将npos定义为一个const string::size_type类型,并初始化为值-1
    • 由于npos是一个unsigned类型,此初始值意味着npos等于任何string最大的可能大小

1
2
3
4
5
6

string::size_type pos = 0;
// 每步循环查找name中下一个数
while((pos=name.find_first_of(numbers,pos))!=string::npos){
  cout<<pos<<name[pos]<<endl;
  ++pos;
}

9.5.4 compare函数

9.5.5 数值转换

• 如果string不能转换为一个数值,这些函数抛出一个invalid_argument异常
• 如果转换得到的数值无法用任何类型来表示,则抛出一个out_of_range异常

9.6 容器适配器

• 顺序容器适配器：stack,queue和priority_queue
• 适配器是标准库中一个通用概念(容器,迭代器和函数都有适配器)
  • 一个内容适配器接受一个已有的容器类型,使其行为看起来像一种不同的类型

• 定义一个适配器：默认构造函数创建一个空对象,接受一个容器的构造函数拷贝该容器来初始化适配器
  • 默认情况下,stack和queue是基于deque实现的,priority_queue是在vector之上实现的
• 对于一个给定的适配器,可以使用哪些容器是有限制的
  • 所有适配器都要求容器具有添加和删除元素的能力(适配器不能构造在array上)
    • 类似的,也不能用forward_list来构造适配器,因为所有适配器都要求容器具有添加、删除以及访问尾元素的能力
  • stack只要求push_back、pop_back和back操作,因此可以使用除array和forward_list之外的任何容器类型来构造stack
  • queue适配器要求back、push_back、front和push_front,因此它可以构造于list或deque之上,但不能基于vector构造
  • priority_queue除了front、push_back和pop_back操作之外还要求随机访问能力,因此它可以构造于vector或deque之上,但不能基于list构造

1
2
3
4
5
6

stack<int> stk(deq);    //从deq拷贝元素到stk

// 在vector上实现的空栈
stack<string,vector<string>> str_stk;
// str_stk2在vector上实现,初始化时保存svec的拷贝
stack<string,vector<string>> str_stk2(svec);

• 栈适配器
  • stack类型定义在stack头文件中
  • 栈默认基于deque实现,也可以在list或vector上实现的

1
2
3
4
5
6
7
8
9
10

stack<int> intStack;

// 填满栈
for(size_t ix = 0;ix!=10;++ix)
  intStack.push(ix);    //intStack保存0到9十个数
while(!intStack.empty()){
  int value = intStack.top();
  // 使用栈顶值的代码
  intStack.pop(); //弹出栈顶元素,继续循环
}

• 队列适配器
  • queue和priority_queue适配器定义在queue头文件中
  • 标准库queue使用一种先进先出(FIFO)的存储和访问策略
  • priority_queue允许我们为队列中的元素建立优先级。新加入的元素会排在所有优先级比它低的已有元素之前
  • queue默认基于deque实现,priority_queue默认基于vector实现
    • queue也可以用list或vector实现,priority_queue可以用deque实现

10 泛型算法

10.1 概述

• 大多数的算法都定义在头文件algorithm中,还在头文件numeric中定义了一组数值泛型算法
  • 一般情况下,算法不直接操作容器,而是遍历由两个迭代器指定的一个元素范围来进行操作(通常情况下,算法遍历范围,对其中每个元素进行一些处理)
• 迭代器令算符不依赖于容器,但算法依赖于元素类型的操作
• 算法永远不会执行容器的操作：
  • 泛型算法本身不会执行容器的操作,它们只会运行于迭代器之上,执行迭代器的操作
  • 泛型算法运行于迭代器之上而不会执行容器操作的特性带来了一个令人惊讶但非常必要的编程假定：算法永远不会改变底层容器的大小
  • 算法可能改变容器中保存的元素的值,也可能在容器内移动元素,但永远不会直接添加或删除元素

10.2 初始泛型算法

10.2.1 只读算法

• 一些算法只会读取输入范围内的元素,而不改变元素
• 对于读取而不改变元素的算法,通常最好使用cbegin()和cend(),但若需要使用算法返回迭代器来改变元素的值,需要使用begin()和end()的结果作为参数

10.2.2 写容器元素的算法

• 一些算法将新值赋予序列中的元素,使用这些算法时,必须注意确保序列原大小至少不小于要求算法写入的元素数目
  • 算法不会执行容器操作,因此自身不可能改变大小

1
2
3
4
5

// 算法fill接受一对迭代器表示一个范围,还接受一个值作为第三个参数
// fill将给定的这个值赋予输入序列的每个元素
fill(vec.begin(),vec.end(),0) //将每个元素重置为0
// 将容器的一个子序列设置为10
fill(vec.begin(),vec.begin()+vec.size()/2,10);

• 迭代器参数
  • 一些算法从两个序列中读取元素。构成这两个序列的元素可以来自于不同类型的容器
  • 操作两个序列的算法之间的区别在于如何传递第二个序列
    • 如equal,接受三个迭代器,前两个表示第一个序列的范围,第三个表示第二个序列的首元素
      • 用一个单一的迭代器表示第二个序列的算法都是假定第二个序列至少与第一个一样长,确保算法不会试图访问第二个序列中不存在的元素
    • 其他算法接受四个迭代器,前两个表示第一个序列的元素范围,后两个表示第二个序列的范围
• 算法不检查写操作
  • 一些算法接受一个迭代器来指出一个单独的目的位置,算法将新值赋予一个序列的元素,该序列从目的位置迭代器指向的元素开始
  • 向目的位置迭代器写入数据的算法假定目的位置足够大,能容纳要写入的元素

1
2
3
4
5
6
7
8
9
10
11
12
13

// 可以用fill_n将一个新值赋予vector中的元素
vector<int> vec;  //空vector
// 使用vec,赋予它不同值
fill_n(vec.begin(), vec.size(), 0);   //将所有元素重置为0

// 函数fill_n假定写入指定个元素是安全的
fill_n(dest, n, val)
// fill_n假定dest指向一个元素,而从dest开始的序列至少包含n个元素

// 在空容器上调用fill_n
vector<int> vec;  //空向量
// 灾难：修改vec中的10个不存在元素
fill_n(vec.begin(), 10, 0);

• 介绍back_inserter
  • 一种保证算法有足够元素空间来容纳数据的方法是使用插入迭代器
  • 插入迭代器是一种向容器中添加元素的迭代器,通常情况通过一个插入迭代器赋值时,一个与赋值号右侧值相等的元素被添加到容器中
  • iterator函数中back_insert函数：接受一个指向容器的引用,返回一个与该容器绑定的插入迭代器
    • 通过此迭代器赋值时,赋值运算符会调用push_back将一个具有给定值的元素添加到容器中

1
2
3
4
5
6
7

vector<int> vec;  //空向量
auto it = back_insert(vec);
*it = 42;

// 使用back_insert创建迭代器,作为算法的目的位置来使用
vector<int> vec;  //空向量
fill_n(back_insert(vec),10,0);  //添加10个元素到vec

• 拷贝算法
  • 是另一个向目的位置迭代器指向的输出序列中的元素写入数据的算法
  • 接受三个迭代器：前两个表示一个输入范围,第三个表示目的序列的起始位置;将输入范围内的元素拷贝到目的系列中
  • copy算法
  • replace算法：读入一个序列,并将其中所有等于给定值的元素都改为另一个值,接收4个参数,前两个是迭代器,表示输入序列,后两个一个是搜索的值,另一个是新值
  • replace_copy：保留原序列不变,需要支持额外的第三个迭代器参数,指出保存后序列的位置

10.2.3 重排容器元素的算法

• sort算法：重排输入序列中的元素,利用元素类型的<运算符来实现排序
• unique算法：重排输入序列,将相邻的重复项消除,并返回一个指向不重复值范围末尾的迭代器
• erase算法：删除无用元素

10.3 定制操作

• 很多算法会比较输入序列的元素：默认情况下,这类算法使用元素类型的<或==运算符完成比较;

10.3.1 向算法传递函数

• 按长度重排vector,将使用sort的重载版本,接收三个参数,此参数是一个谓词
  • 谓词：是一个可调用的表达式,其返回结果是一个能用作条件的值
    • 接收谓词参数的算法对输入序列中的元素调用谓词,因此元素类型必须能转换为谓词的参数类型
  • 接收二元谓词的sort版本用谓词代替<来比较元素
• stable_sort算法：保持等长元素间的字典序,重排输入序列中的元素

1
2
3
4
5
6
7

// 比较函数,用来按长度排序单词
bool isShorter(const string &s1, const string &s2){
  return s1.size() < s2.size();
}

// 按长度由短至长排序
sort(words.begin(),words.end(),isShorter);

10.3.2 lambda表达式

• 可以向一个算法传递任何类别的可调用对象
  • 对于一个对象或一个表达式,如果可以对其调用运算符,则称它为可调用的,e为一个可调用表达式,则可编写e(args),其中args是一个逗号分割的一个或多个参数列表
  • ==可调用对象：函数,函数指针,重载了函数调用运算符的类,lambda表达式
• lambda表达式：表示一个可调用单元源代码,可理解为一个未命名的内联函数(具有返回类,参数列表和函数体),可定义在函数内部
  • lambda表达式的形式:[capture list](parameter list) -> return type{function body}
    • capture list是一个lambda所在函数中定义的局部变量的列表;
    • 可以忽略参数列表和返回类型,但必须永远包含捕获列表和函数体
    • 忽略参数列表等价于一个空参数列表,若忽略返回类型,lambda根据函数体中的代码推断出返回类型;若函数体只是一个return语句,则返回类型从返回表达式的类型推断而来
• 向lambda传递参数
  • 调用lambda时给定的实参会被用来初始化lambda的形参,但不能带默认参数(因此lambda调用的实参数目永远与形参数目相等)
  • 空捕获列表表示lambda不使用它所在函数中的任何局部变量
• 使用捕获列表
  • 捕获列表指引lambda在其内部包含访问局部变量所需的信息
  • 一个lambda通过将局部变量包含在其捕获列表中指出将会使用这些变量
  • 一个lambda只有在其捕获列表中捕获一个它所在函数中的局部变量,才能在函数体中使用该变量
  • 捕获列表只用于局部非static变量,lambda可以直接使用局部static变量和它所在函数之外声明的名字
• for_each算法
  • 使用for_each接收一个可调用对象,并将输入序列中每个元素调用此对象

1
2
3
4
5
6
7
8

stable_sort(words.begin(),words.end(),
  [](const string &a, const string &b) {return a.size() < b.size();})

[sz](const string &a) {return a.size() >= sz;}

for_each(wc,words.end(),
    [](const string &s) {cout << s << " ";})
cout << endl;  

10.3.3 lambda捕获和返回

• 当定义一个lambda时,编译器生成一个与lambda对应的新的类类型
  • 当向一个函数传递一个lambda时,同时定义了一个新类型和该类型的一个对象：传递的参数就是此编译器生成的类类型的未命名对象(当使用auto定义一个用lambda初始化的变量时,定义了一个从lambda生成的类型的对象)
  • 默认情况下,从lambda生成的类都包含一个对应该lambda所捕获的变量的数据成员
• 值捕获
  • 被捕获的变量的值是在lambda创建时拷贝,而不是调用时拷贝
• 引用捕获
  • 一个以引用方式捕获的变量与其他任何类型的引用的行为类似
  • 在lambda函数体内使用此变量时,实际上使用的是引用所绑定的对象
  • 采用引用方式捕获一个变量,就必须确保被引用的对象在lambda执行的时候是存在的
• 建议：尽量保持lambda的变量捕获简单
  • 捕获一个普通变量,如int、string或其他非指针类型,通常可以采用简单的值捕获方式。在此情况下,只需关注变量在捕获时是否有所需的值就可以了
  • 如果捕获一个指针或迭代器,或采用引用捕获方式,就必须确保在lambda执行时,绑定到迭代器、指针或引用的对象仍然存在。而且,需要保证对象具有预期的值
• 隐式捕获
  • 让编译器根据lambda体中的代码来推断要使用变量
  • 应在捕获列表中写一个&或=
    • &告诉编译器采用捕获引用方式
    • =表示采用值捕获方式
  • 混合使用隐式捕获和显式捕获时,捕获列表中的第一个元素必须是一个&或=(指定了默认捕获方式为引用或值),且显式捕获和隐式捕获必须采用不同的方式
• 可变lambda
  • 默认情况下,对于一个值被拷贝的变量,lambda不会改变其值,若希望能改变一个被捕获的变量的值,必须在参数列表首加上关键字mutable
    • 可变lambda能省略参数列表
  • 引用可以修改依赖于此引用指向的是一个const类型还是非const类型
• 指定lambda返回类型
  • 为一个lambda定义返回类型时,必须使用尾置返回类型(跳转尾置返回类型)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void fcn1(){
  size_t v1 = 42;
  auto f = [v1] {return v1;};
  v1 = 0;
  auto j = f();   //j值为42
  // 由于被捕获变量的值是在lambda创建时拷贝,因此随后对其修改不会影响到lambda内对应的值
}

void fcn2(){
  size_t v1 = 42;
  auto f = [&v1] {return v1;};
  v1 = 0;
  auto j = f();   //j值为0
}

wc = find_if(words.begin(),words.end(),
          [=](const string &s) {return s.size() >= sz;})

// 可变lambda
void fcn3(){
  size_t v1 = 42;
  auto f = [v1]() mutable {return ++v1;};
  v1 = 0;
  auto j = f();   //j值为43
}

transform(vi.begin(),vi.end(),vi.begin(),
        [](int i) -> int 
        {if(i<0) return -i; else return i;});

10.3.4 参数绑定

• 对于捕获局部变量的地方,建议使用lambda
• 标准库bind函数：
  • 定义在头文件functional中
  • 可将bind函数看作一个通用的函数适配器,接受一个可调用对象,生成一个新的可调用对象来适应原对象的参数列表
  • 调用的一般形式：auto newCallable = bind(callable,arg_list);
    • 其中,newCallable本身是一个可调用对象,arg_list是一个逗号分隔的参数列表,对应给定的callable的参数
    • 当调用newCallable时,newCallable会调用callable,并传递给它arg_list中的参数。arg_list中的参数可能包含形如_n的名字,其中n是一个整数。这些参数是“占位符”,表示newCallable的参数,占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数,_2为第二个参数,依此类推
• 使用placeholders名字
  • 定义在头文件functional中
  • 名字_n都定义在一个名为placeholders的命名空间中,而这个命名空间本身定义在std命名空间中
  • 为了使用这些名字,两个命名空间都要写上
• 用bind重排参数顺序
• 绑定引用
  • 默认情况下,bind的不是占位符的参数被拷贝进bind返回的可调用对象中,但有时对有些绑定的参数希望以引用方式传递或时要绑定的参数的类型无法拷贝
  • ref和cref定义在functional中
  • ref函数：返回一个对象,包含给定的引用,此对象是可以拷贝的
  • cref函数：生成一个保存const引用的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35