虚函数

• 用virtual关键字说明的函数
• 虚函数是实现运行时多态性基础
• C++中的虚函数是动态绑定的函数
• 虚函数必须是非静态的成员函数，虚函数经过派生之后，就可以实现运行过程中的多态

什么函数可以是虚函数

• 一般成员函数可以是虚函数
• 构造函数不能是虚函数
• 析构函数可以是虚函数

一般虚函数成员

• 虚函数的声明

  virtual 函数类型 函数名（形参表);

• 虚函数声明只能出现在类定义中的函数原型声明中,而不能在成员函数实现的时候

• 在派生类中可以对基类中的成员函数进行覆盖

• 虚函数一般不声明为内联函数，因为对虚函数的调用需要动态绑定,而对内联函数的处理是静态的

virtual 关键字

• 派生类可以不显式地用virtual声明虚函数,这时系统就会用以下规则来判断派生类的一个成员函数是不是虚函数:
  • 该函数是否与基类的虚函数有相同的名称、参数个数以及对应参数类型
  • 该函数是否与基类的虚函数有相同的返回值或者满足类型兼容规则的指针、引用型的返回值
• 如果从名称、参数以及返回值三个方面检查后，派生类的函数满足了上述条件，就会自动确定为虚函数。这时派生类的虚函数就会覆盖基类的虚函数
• 派生类的虚函数还会隐藏基类中同名函数的所有其他重载形式
• 一般习惯在派生类的函数中也使用virtual关键字，以增加程序的可读性

虚析构函数

如果你打算允许其他人通过基类指针调用对象的析构函数(通过delete这样做是正常的),就需要让基类的析构函数成为虚函数,否则执行delete的结果是不确定的

• 面向对象程序设计（object-oriented programming）的核心思想是数据抽象、继承和动态绑定
• 继承（inheritance）
  • 通过继承联系在一起的类构成一种层次关系
  • 通常在层次关系的根部有一个基类（base class）
  • 其他类直接或者简介从基类继承而来，这些继承得到的类成为派生类（derived class）
  • 基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类定义各自特有的成员
  • 对于某些函数，基类希望它的派生类个自定义适合自己的版本，此时基类就将这些函数声明成虚函数（virtual function）
  • 派生类必须通过使用类派生列表（class derivation list）明确指出它是从哪个基类继承而来。形式：一个冒号，后面紧跟以逗号分隔的基类列表，每个基类前都可以有访问说明符。class Bulk_quote : public Quote{};
  • 基类通过在其成员函数的声明语句之前加上关键字virtual使得该函数执行动态绑定。任何构造函数之外的非静态函数都可以是虚函数。关键字virtual只能出现在类内部的声明语句之前而不能用于类外部的函数定义。如果基类把一个函数声明成虚函数，则该函数在派生类中隐式地也是虚函数
  • 派生类必须在其内部对所有重新定义的虚函数进行声明。可以在函数之前加上virtual关键字，也可以不加。C++11新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，即在函数的形参列表之后加一个override关键字
• 动态绑定（dynamic binding，又称运行时绑定）
  • 使用同一段代码可以分别处理基类和派生类的对象
  • 函数的运行版本由实参决定，即在运行时选择函数的版本

定义基类和派生类

定义基类

• 基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此
• 基类通过在其成员函数的声明语句前加上关键字virtual使得该函数执行动态绑定
• 如果成员函数没有被声明为虚函数，则解析过程发生在编译时而非运行时
• 访问控制
  • protected ： 基类和和其派生类还有友元可以访问
  • private ： 只有基类本身和友元可以访问

定义派生类

• 派生类必须通过类派生列表（class derivation list）明确指出它是从哪个基类继承而来。形式：冒号，后面紧跟以逗号分隔的基类列表，每个基类前面可以有一下三种访问说明符的一个：public、protected、private
• C++11新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，即在函数的形参列表之后加一个override关键字
• 派生类构造函数：派生类必须使用基类的构造函数去初始化它的基类部分
• 静态成员：如果基类定义了一个基类成员，则在整个继承体系中只存在该成员的唯一定义
• 派生类的声明：声明中不包含它的派生列表
• C++11新标准提供了一种防止继承的方法，在类名后面跟一个关键字final

类型转换与继承

• 理解基类和派生类之间的类型关键是理解C++语言面向对象编程的关键所在
• 可以将基类的指针或引用绑定到派生类对象上
• 不存在从基类向派生类的隐式类型转换
• 派生类向基类的自动类型转换只对指针或引用类型有效，对象之间不存在类型转换

虚函数

• 使用虚函数可以执行动态绑定
• OOP的核心思想是多态性（polymorphism）
• 当且仅当对通过指针或引用调用虚函数时，才会在运行时解析该调用，也只有在这种情况下对象的动态类型才有可能与静态类型不同
• 派生类必须在其内部对所有重新定义的虚函数进行声明。可以在函数之前加上virtual关键字，也可以不加
• C++11新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，即在函数的形参列表之后加一个override关键字
• 如果我们想覆盖某个虚函数，但不小心把形参列表弄错了，这个时候就不会覆盖基类中的虚函数。加上override可以明确程序员的意图，让编译器帮忙确认参数列表是否出错
• 如果虚函数使用默认实参，则基类和派生类中定义的默认实参最好一致
• 通常，只有成员函数（或友元）中的代码才需要使用作用域运算符（::）来回避虚函数的机制

抽象基类

• 纯虚函数（pure virtual）：清晰地告诉用户当前的函数是没有实际意义的。纯虚函数无需定义，只用在函数体的位置前书写=0就可以将一个虚函数说明为纯虚函数
• 含有纯虚函数的类是抽象基类（abstract base class）。不能创建抽象基类的对象

访问控制与继承

• 受保护的成员
  • protected说明符可以看做是public和private中的产物
  • 类似于私有成员，受保护的成员对类的用户来说是不可访问的
  • 类似于公有成员，受保护的成员对于派生类的成员和友元来说是可访问的
  • 派生类的成员或友元只能通过派生类对象来访问基类的受保护成员。派生类对于一个基类对象中的受保护成员没有任何访问特权
• 派生访问说明符
  • 对于派生类的成员（及友元）能否访问其直接基类的成员没什么影响
  • 派生访问说明符的目的是：控制派生类用户对于基类成员的访问权限。比如struct Priv_Drev: private Base{}意味着在派生类Priv_Drev中，从Base继承而来的部分都是private的
• 友元关系不能继承
• 改变个别成员的可访问性：使用using
• 默认情况下，使用class关键字定义的派生类是私有继承的；使用struct关键字定义的派生类是公有继承的

继承中的类作用域

• 每个类定义自己的作用域，在这个作用域内我们定义类的成员。当存在继承关系时，派生类的作用域嵌套在其基类的作用域之内
• 派生类的成员将隐藏同名的基类成员
• 除了覆盖继承而来的虚函数之外，派生类最好不要重用其他定义在基类中的名字

构造函数与拷贝控制

虚析构函数

• 基类通常应该定义一个虚析构函数，这样我们就能动态分配继承体系中的对象了
• 如果基类的析构函数不是虚函数，则delete一个指向派生类对象的基类指针将产生未定义的行为
• 虚析构函数将阻止合成移动操作

合成拷贝控制与继承

• 基类或派生类的合成拷贝控制成员的行为和其他合成的构造函数、赋值运算符或析构函数类似：他们对类本身的成员依次进行初始化、赋值或销毁的操作

派生类的拷贝控制成员

• 当派生类定义了拷贝或移动操作时，该操作负责拷贝或移动包括基类部分成员在内的整个对象
• 派生类析构函数：派生类析构函数先执行，然后执行基类的析构函数

继承的构造函数

• C++11新标准中，派生类可以重用其直接基类定义的构造函数
• 如using Disc_quote::Disc_quote;，注明了要继承Disc_quote的构造函数

容器与继承

• 当我们使用容器存放继承体系中的对象时，通常必须采用间接存储的方式
• 派生类对象直接赋值给基类对象，其中的派生类部分会被切掉
• 在容器中放置（智能）指针而非对象
• 对于C++面向对象的编程来说，一个悖论是我们无法直接使用对象进行面向对象编程。相反，我们必须使用指针和引用。因为指针会增加程序的复杂性，所以经常定义一些辅助的类来处理这些复杂的情况

基本概念

• 重载运算符是具有特殊名字的函数：由关键字operator和其后要定义的运算符号共同组成
• 当一个重载的运算符是成员函数时，this绑定到左侧运算对象。动态运算符符函数的参数数量比运算对象的数量少一个
• 只能重载大多数的运算符，而不能发明新的运算符号
• 重载运算符的优先级和结合律跟对应的内置运算符保持一致
• 调用方式
  • data1 + data2;
  • operator+(data1, data2);
• 是否是成员函数
  • 赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）运算符必须是成员
    • 要保证这几个符号都是被对象调用,使用友元会出现语义问题,friend int operator=(int a, int b); 2 = a;
  • 复合赋值运算符一般来说是成员
  • 改变对象状态的运算符或者和给定类型密切相关的运算符通常是成员，如递增、解引用
  • 具有对称性的运算符如算术、相等性、关系和位运算符等，通常是非成员函数

运算符

通常情况下，不应该重载逗号、取地址、逻辑与和逻辑或运算符

输入和输出运算符

重载输出运算符<<

• 第一个形参通常是一个非常量的ostream对象的引用。非常量是因为向流中写入会改变其状态；而引用是因为我们无法复制一个ostream对象
• 输入输出运算符必须是非成员函数(运算符左侧对象必须是是iostream,不能是this)

重载输入运算符>>

• 第一个形参通常是运算符将要读取的流的引用，第二个形参是将要读取到的（非常量）对象的引用
• 输入运算符必须处理输入可能失败的情况，而输出运算符不需要

算数和关系运算符（+、-、*、/）

• 如果类同时定义了算数运算符和相关的复合赋值运算符，则通常情况下应该使用复合赋值来实现算数运算符

相等运算符==

• 如果定义了operator==，则这个类也应该定义operator!=
• 相等运算符和不等运算符的一个应该把工作委托给另一个
• 相等运算符应该具有传递性
• 如果某个类在逻辑上有相等性的含义，则该类应该定义operator==，这样做可以使用户更容易使用标准库算法来处理这个类

关系运算符

• 如果存在唯一一种逻辑可靠的<定义，则应该考虑为这个类定义<运算符。如果同时还包含==，则当且仅当<的定义和==产生的结果一直时才定义<运算符

赋值运算符=

• 我们可以重载赋值运算符。不论形参的类型是什么，赋值运算符都必须定义为成员函数
• 赋值运算符必须定义成类的成员，复合赋值运算符通常情况下也应该这么做。这两类运算符都应该返回左侧运算对象的引用

下标运算符[]

• 下标运算符必须是成员函数
• 一般会定义两个版本
  • 返回普通引用
  • 类的常量成员，并返回常量引用

递增和递减运算符（++、–）

• 定义递增和递减运算符的类应该同时定义前置版本和后置版本
• 通常应该被定义成类的成员
• 为了和内置版本保持一致，前置运算符应该返回递增或递减后对象的引用
• 同样为了和内置版本保持一致，后置运算符应该返回递增或递减前对象的值，而不是引用
• 后置版本接受一个额外的，不被使用的int类型的形参。因为不会用到，所以无需命名

成员访问运算符（*、->）

• 箭头运算符必须是类的成员。解引用运算符通常也是类的成员，尽管并非必须如此
• 对于形如point->mem的表达式来说，point必须是指向类对象的指针或者是一个重载了operator->的类的对象
  • (*point).mem point是指针
  • point.operator()->mem point是对象
• 解引用和乘法的区别是一个是一元运算符，一个是二元运算符

函数调用运算符

• 可以像使用函数一样，调用该类的对象。因为这样对待类同时也能存储状态，所以与普通函数相比更加灵活
• 函数调用运算符必须是成员函数
• 一个类可以定义多个不同版本的调用运算符，相互之间应该在参数数量或类型上有所区别
• 如果累定义了调用运算符，则该类的对象称作函数对象

lambda是函数对象

• lambda捕获变量：lambda产生的类必须为每个值捕获的变量建立对应的数据成员，同时创建构造函数

标准库定义的函数对象

标准库函数对象

• 可以在算法中使用标准库函数对象

可调用对象与function

标准库function类型

• 例如：声明一个function类型，它可以表示接受两个int，返回一个int的可调用对象。function<int(int, int)>

重载、类型转换、运算符

类型转换运算符

• 类型转换运算符是类的一种特殊成员函数，它负责将一个类类型的值转换成其他类型。类型转换函数的一般形式如下：operator type() const;
• 一个类型转换函数必须是类的成员函数；它不能声明返回类型，形参列表也必须为空。类型转换函数通常应该是const
• 避免过度使用类型转换函数
• C++11引入了显式的类型转换运算符
• 向bool的类型转换通常用在条件部分，因此operator bool一般定义成explicit的

避免有二义性的类型转换

• 通常，不要为类定义相同的类型转换，也不要在类中定义两个及以上转换源或转换目标是算术类型的转换
• 在调用重载函数时，如果需要额外的标准类型转换，则该转换的级别只有当所有可行函数都请求同一个用户定义的类型转换时才有用。如果所需的用户定义的类型转换不止一个，则该调用具有二义性

函数匹配与重载运算符

• 如果a是一种类型，则表达式a sym b可能是
  • a.operatorsym(b);
  • operatorsym(a,b);
• 如果我们对同一个类既提供了转换目标是算术类型的类型转换，也提供了重载的运算符，则将会遇到重载运算符与内置运算符的二义性问题

demo

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

class CDemo
{    
    friend std::ostream& operator<<(std::ostream&, const CDemo&); 
    friend std::istream& operator>>(std::istream&, CDemo&);
    friend CDemo operator+(const CDemo&, const CDemo&);

public:
    explicit CDemo(int num = 0): m(num) {} 
    ~CDemo() {}
    CDemo(const CDemo &d): m(d.m) {}

    CDemo& operator=(const CDemo &d) {
        m = d.m;
        return *this;
    }

    CDemo operator++(int) {
        std::cout << "d++" << std::endl;
        CDemo tmp(*this);
        ++*this;
        return tmp;
    }

    CDemo& operator++() {
        std::cout << "++d" << std::endl;
        ++m;
        return *this;
    }

	CDemo& operator+=(const CDemo& d) {
        m += d.m;
        return *this;
    }

    void operator()() {
        std::cout << "d()" << std::endl;
    }

    int operator[](size_t n) {
        std::cout << "[]" << std::endl;
        return m;
    }

    std::string& operator*() {
        std::cout << "*" << std::endl;
        return str;
    }

    std::string* operator->() {
        std::cout << "->" << std::endl;
        return & this->operator*();
    }

    operator int() const {
        return m;
    }

    int get() {
        return m;
    }

private:
    int m;
    std::string str = "abc";
};

std::ostream& operator<<(std::ostream& stream, const CDemo& d)
{
    return stream << d.m;
}

std::istream& operator>>(std::istream& stream, CDemo& d)
{
    stream >> d.m;
    if (!stream) {
        d = CDemo(-1);
    }
    return stream;
}

CDemo operator+(const CDemo& d1, const CDemo& d2)
{
    CDemo d = d1;
    d += d2;
    return d;
}

概念

C语言中的表达式被分为左值和其它(函数和非对象值)，其中左值被定义为标识一个对象的表达式。在C语言中lvalue是locator value的简写，因此lvalue对应了一块内存地址。

C++11之前，左值遵循了C语言的分类法，但与C不同的是，其将非左值表达式统称为右值，函数为左值，并添加了引用能绑定到左值但唯有const的引用能绑定到右值的规则。几种非左值的C表达式在C++中成为了左值表达式。

自C++11开始，对值类别又进行了详细分类，在原有左值的基础上增加了纯右值和消亡值，并对以上三种类型通过是否具名(identity)和可移动(moveable)，又增加了glvalue和rvalue两种组合类型。

• 具名(identity):可以确定表达式是否与另一表达式指代同一实体，例如通过比较它们所标识的对象或函数的（直接或间接获得的）地址
• 可被移动(moveable)：移动构造函数、移动赋值运算符或实现了移动语义的其他函数重载能够绑定于这个表达式

表达式是可求值的，对表达式求值可得到一个结果，这个结果有两个属性

• 类型，比如int、string、引用或者我们自定义的类
• 值类别
  • 在C++11之前，表达式的值分为左值和右值两种，其中右值就是我们理解中的字面值1、true、nullptr等
  • 自C++11开始，表达式的值分为左值(lvalue, left value)、将亡值(xvalue, expiring value)、纯右值(pvalue, pure ravlue)以及两种混合类别泛左值(glvalue, generalized lvalue)和右值(rvalue, right value)五种

值类别

• 左值(lvalue):具名且不可被移动
• 将亡值(xvaue):具名且可被移动
• 纯右值(prvalue):不具名且可被移动
• 泛左值(glvalue):具名，lvalue和xvalue都属于glvalue
• 右值(rvalue):可被移动的表达式，prvalue和xvalue都属于rvalue

左值 (lvalue,left value)

顾名思义就是赋值符号左边的值。准确来说，左值是表达式结束（不一定是赋值表达式）后依然存在的对象。

可以将左值看作是一个关联了名称的内存位置，允许程序的其他部分来访问它。在这里，我们将 “名称” 解释为任何可用于访问内存位置的表达式。所以，如果arr是一个数组，那么arr[1]和*(arr+1)都将被视为相同内存位置的“名称”。

特征

• 可通过取地址运算符获取其地址
• 可修改的左值可用作内建赋值和内建符合赋值运算符的左操作数
• 可以用来初始化左值引用

举例

• 变量名、函数名以及数据成员名 int a = 5
• 返回左值引用的函数调用 T& f(); f();
• 由赋值运算符或复合赋值运算符连接的表达式，a=b;
• 解引用表达式 int *ptr = &a;
• 前置自增和自减表达式 ++a;
• 成员访问.运算符的结果 obj.m
• 由指针访问成员->运算符的结果 p->m
• 下标运算符的结果[] arr[0] = 10
• 字符串字面值"abc"

对于一个表达式，凡是对其取地址（&）操作可以成功的都是左值

纯右值 (pvalue, pure ravlue)

自C++11开始，纯右值(pvalue, pure ravlue)相当于之前的右值,字面值或者函数返回的非引用都是纯右值。

特征

• 等同于C++11之前的右值
• 不会是多态
• 不会是抽象类型或数组
• 不会是不完全类型

举例

• 字面值(字符串字面值除外) 1; 'a'; true;
• 返回值为非引用的函数调用或操作符重载int f(); f(); str1 + str2; it++;
• 后置自增和自减表达式 a++;
• 算术表达式 a+b;
• 逻辑表达式 a && b;
• 比较表达式 a > b;
• 取地址表达式 &a;
• lambda表达式 []{};

将亡值(xvalue, expiring value)

顾名思义即将消亡的值，是C++11新增的跟右值引用相关的表达式，通常是将要被移动的对象（移为他用），比如返回右值引用T&&的函数返回值、std::move的返回值，或者转换为T&&的类型转换函数的返回值。

将亡值可以理解为通过“盗取”其他变量内存空间的方式获取到的值。在确保其他变量不再被使用、或即将被销毁时，通过“盗取”的方式可以避免内存空间的释放和分配，能够延长变量值的生命期。（通过右值引用来续命）。

xvalue 只能通过两种方式来获得，这两种方式都涉及到将一个左值赋给(转化为)一个右值引用

• 返回右值引用的函数的调用表达式,如T&& f(); f();该表达式得到一个xvalue
• 转换为右值引用的转换函数的调用表达式，如：std::move(t)、satic_cast<T&&>(t)

1
2
3
4
5
6
7

std::string fun() {
  std::string str;
  // ...
  return str;
}

std::string s = fun();

在函数fun()中，str是一个局部变量，并在函数结束时候被返回。

在C++11之前，s = fun();会调用拷贝构造函数，会将整个str复制一份，然后把str销毁。如果str特别大的话，会造成大量额外开销。在这一行中，s是左值，fun()是右值(纯右值)，fun()产生的那个返回值作为一个临时值，一旦str被s复制后，将被销毁，无法获取、也不能修改。

自C++11开始，引入了move语义，编译器会将这部分优化成move操作，即不再是之前的复制操作，而是move。此时，str会被进行隐式右值转换，等价于static_cast<std::string&&>(str)，进而此处的s会将fun局部返回的值进行移动。

无论是C++11之前的拷贝，还是C++11的move，str在填充(拷贝或者move)给s之后，将被销毁，而被销毁的这个值，就成为将亡值。

将亡值就定义了这样一种行为：具名的临时值、同时又能够被move。

泛左值（glvalue, generalized lvalue）

又称为广义左值，是具名表达式，对应了一块内存。glvalue有lvalue和xvalue两种形式。

特征

• 可以自动转换成prvalue
• 可以是多态的
• 可以是不完整类型，如前置声明但未定义的类类型

右值(rvalue, right value)

是指可以移动的表达式,prvalue和xvalue都是rvalue。

特征

• 无法对rvalue进行取地址操作。例如：&1; &(a + b);，这些表达式没有意义，也编译不过
• rvalue不能放在赋值或者组合赋值符号的左边。例如：3 = 5; 3 += 5; 这些表达式没有意义，也编译不过
• rvalue可以用来初始化const左值引用。例如：const int& a = 1;
• rvalue可以用来初始化右值引用
• rvalue可以影响函数重载：当被用作函数实参且该函数有两种重载可用，其中之一接受右值引用的形参而另一个接受const的左值引用的形参时，右值将被绑定到右值引用的重载之上

例

前置自增(减)是左值，后置自增(减)是纯右值

1
2
3
4
5

int i = 0;
++i;
--i;
i++;
i--;

在上面代码中，我们定义了一个int类型的变量i，并初始化为0。

• ++i的操作是对i加1后再赋值给i，所以++i的结果是具名的，名称就是i，所以++i是左值
• 对于i++而言，先将i的值进行拷贝(此处假设拷贝到临时变量ii)，然后再对i加1，最后返回ii(其实不存在的，为了在此表述方便)。所以i++是不具名的，因此不是glvaue，所以i++是右值，又因为不具名，且是右值，所以i++是纯右值
• 同理，–i是左值，i–是纯右值

算术表达式是纯右值

1
2
3
4
5

int x = 0;
int y = 0;
x + y;
x && y;
x == y;

在上述代码中,x + y得到的是一个不具名的临时对象，所以x+y是纯右值；而x && y和x == y得到的是一个bool常量值，要么是true要么是false，所以是纯右值。

解引用是左值，取地址是纯右值

1
2
3
4

int x = 0;
int *y = &x;
*y = 1;
&y;

*y得到的是y指向地址的实际值，所以&(*y)是合法的，因此*y是左值;对&y操作得到的是一个地址，即一个long值，所以是一个字面值，因此&y是纯右值。

字符串字面值是左值

1

std::cout << &"abc" << std::endl;

字符串字面值为左值，这个比较特殊。在前面提到过字面值都是纯右值(字符串字面值除外)，一个很重要的原因，就是可以字符串字面值可以获取地址，

这是因为C++将字符串字面值实现为char型数组，实实在在地为每个字符都分配了空间并且允许程序员对其进行操作。如果从存储区的概念来理解，那就是字符串字面值存储在常量区。

左值引用

1
2
3
4
5

int a = 5;
int &ref = a; //左值引用

int &f1 = 5; //错误
const int &f2 = 5; //只有常量左值引用能绑定到常量

右值引用

右值引用的引入，使得可以延长右值的生命周期。在C++中规定，右值引用是&&即由2个&表示，而左值引用是一个&表示。右值引用的作用是为了绑定右值

右值引用虽然是引用右值，但是其本身是左值

1

int &&a = 1;

在上述代码中，a是一个右值引用，但是其本身是左值

• a出现在等号=的左边
• 可以对a取地址

判断是否是左值引用和右值引用

1
2
3
4
5

int a = 5;
int &lref = a;
int &&rref = 7;
std::cout << std::is_lvalue_reference<decltype(lref)>::value << std::endl;
std::cout << std::is_rvalue_reference<decltype(rref)>::value << std::endl;

拷贝控制操作（copy control）

• 拷贝构造函数（copy constructor）
• 拷贝赋值运算符（copy-assignment operator）
• 移动构造函数（move constructor）
• 移动赋值函数（move-assignement operator）
• 析构函数（destructor）

拷贝、赋值和销毁

拷贝构造函数

• 如果一个构造函数的第一个参数是自身类类型的引用，且任何额外参数都有默认值，则此构造函数是拷贝构造函数
• class Foo{ public: Foo(const Foo&); }
• 合成的拷贝构造函数（synthesized copy constructor）：会将参数的成员逐个拷贝到正在创建的对象中
• 拷贝初始化
  • 将右侧运算对象拷贝到正在创建的对象中，如果需要，还需进行类型转换
  • 通常使用拷贝构造函数完成
  • string book = "9-99"; (编译器可以绕过拷贝构造函数直接创建对象，但是拷贝构造函数必须存在)
  • 出现场景
    • 用=定义变量时
    • 将一个对象作为实参传递给一个非引用类型的形参
    • 从一个返回类型为非引用类型的函数返回一个对象
    • 用花括号列表初始化一个数组中的元素或者一个聚合类中的成员

拷贝赋值运算符

• 重载赋值运算符
  • 重写一个名为operator=的函数
  • 通常返回一个指向其左侧运算对象的引用
  • Foo& operator=(const Foo&);
• 合成拷贝赋值运算符
  • 将右侧运算对象的每个非static成员赋予左侧运算对象的对应成员

析构函数

• 释放对象所使用的资源，并销毁对象的非static数据成员
• 名字由波浪号接类名构成。没有返回值，也不接受参数
• ~Foo();
• 调用时机
  • 变量在离开其作用域时
  • 当一个对象被销毁时，其成员被销毁
  • 容器被销毁时，其元素被销毁
  • 动态分配的对象，当对指向它的指针应用delete运算符时
  • 对于临时对象，当创建它的完整表达式结束时
• 合成析构函数
  • 空函数体执行完后，成员会被自动销毁
  • 注意：析构函数体本身并不直接销毁成员

三/五法则

• 需要析构函数的类也需要拷贝和赋值操作
• 需要拷贝操作的类也需要赋值操作，反之亦然

使用=default

• 可以通过将拷贝控制成员定义为=default来显式地要求编译器生成合成的版本
• 合成的函数将隐式地声明为内联的

阻止拷贝

• 大多数类应该定义默认构造函数、拷贝构造函数和拷贝赋值运算符，无论是隐式地还是显式地
• 定义删除的函数：=delete
• 虽然声明了它们，但是不能以任何方式使用它们
• 析构函数不能是删除的成员
• 如果一个类有数据成员不能默认构造、拷贝、复制或者销毁，则对应的成员函数将被定义为删除的
• 老版本使用private声明来阻止拷贝

拷贝控制和资源管理

• 类的行为可以像一个值，也可以像一个指针
  • 行为像值：对象有自己的状态，副本和原对象是完全独立的
  • 行为像指针：共享状态，拷贝一个这种类的对象时，副本和原对象使用相同的底层数据

交换操作

• 管理资源的类通常还定义一个名为swap的函数
• 经常用于重排元素顺序的算法
• 用swap而不是std::swap

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include <string>
#include <iostream>

class HasPtr {
public:
    HasPtr(const std::string &s = std::string()) : ps(new std::string(s)), i(0) { }
    HasPtr(const HasPtr &hp) : ps(new std::string(*hp.ps)), i(hp.i) { }
    HasPtr& operator=(const HasPtr &hp) {
        auto new_p = new std::string(*hp.ps);
        delete ps;
        ps = new_p;
        i = hp.i;
        return *this;
    }
    ~HasPtr() {
        delete ps;
    } 

    inline void swap(HasPtr &ptr) noexcept {
        using std::swap;
        swap(ps, ptr.ps);
        swap(i, ptr.i);
    }
    
    void show() { std::cout << *ps << std::endl; }
private:
    std::string *ps;
    int i;
};


//类型特定版本的std::swap优先级高于标准std中的swap
namespace std {
    template<>
    void swap<HasPtr>(HasPtr &ptrA, HasPtr &ptrB) {
        std::cout << "----std::swap----" << std::endl;
        ptrA.swap(ptrB);
    }
}

void swap(HasPtr& lhs, HasPtr& rhs) {
    lhs.swap(rhs);
    std::cout << "----test::swap----" << std::endl;
}

int main() {
    HasPtr a("aaa");
    HasPtr b("bbb");
    using std::swap;
    std::swap(a, b);
    swap(a, b); //如果存在类型特定的swap版本，其匹配程度会优于std中定义的版本
}

对象移动

• 很多拷贝操作后，原对象会被销毁，因此引入移动操作可以大幅度提升性能
• 在新标准中，我们可以用容器保存不可拷贝的类型，只要它们可以被移动即可
• 标准库容器、string和shared_ptr类既可以支持移动也支持拷贝。IO类和unique_ptr类可以移动但不能拷贝

右值引用

• 新标准引入右值引用以支持移动操作
• 通过&&获得右值引用
• 只能绑定到一个将要销毁的对象
• 常规引用可以称之为左值引用
• 左值持久，右值短暂

move函数：

• int &&rr2 = std::move(rr1);
• move告诉编译器，我们有一个左值，但我希望像右值一样处理它
• 调用move意味着：除了对rr1赋值或者销毁它外，我们将不再使用它

移动构造函数和移动赋值运算符

• 移动构造函数
  • 第一个参数是该类类型的一个引用，关键是，这个引用参数是一个右值引用
  • StrVec::StrVec(StrVec &&s) noexcept{}
  • 不分配任何新内存，只是接管给定的内存
• 移动赋值运算符
  • StrVec& StrVec::operator=(StrVec && rhs) noexcept{}
• 移动右值，拷贝左值
• 如果没有移动构造函数，右值也被拷贝
• 更新三/五法则：如果一个类定义了任何一个拷贝操作，它就应该定义所有五个操作
• 移动迭代器
  • make_move_iterator函数讲一个普通迭代器转换为一个移动迭代器
• 建议：小心地使用移动操作，以获得性能提升

右值引用和成员函数

• 区分移动和拷贝的重载函数通常有一个版本接受一个const T&，而另一个版本接受一个T&&
• 引用限定符
  • 在参数列表后面放置一个&，限定只能向可修改的左值赋值而不能向右值赋值
  • 引用限定符可以是&或&&，分别指出this可以指向一个左值或右值
  • 引用限定符只能用于（非static）成员函数，且必须同时出现在函数的声明和定义中
  • 引用限定符必须跟随在const限定符之后

• 对象的生命周期

  • 全局对象在程序启动时分配，结束时销毁
  • 局部对象在进入程序块时创建，离开块时销毁
  • 局部static对象在第一次使用前分配，在程序结束时销毁
  • 动态分配对象：只能显式地被释放

• 对象的内存位置

  • 静态内存用来保存局部static对象、类static对象、定义在任何函数之外的变量
  • 栈内存用来保存定义在函数内的非static对象
  • 堆内存，又称自由空间，用来存储动态分配的对象

动态内存与智能指针

• 动态内存管理
  • new：在动态内存中为对象分配空间并返回一个指向该对象的指针
  • delete：接受一个动态对象的指针，销毁该对象，并释放与之关联的内存
• 智能指针
  • 管理动态对象
  • 行为类似常规指针
  • 负责自动释放所指向的对象
  • 智能指针也是模板

shared_ptr类

shared_ptr和unique_ptr都支持的操作

shared_ptr独有的操作

• 使用动态内存的三种原因
  • 程序不知道自己需要使用多少对象（比如容器类）
  • 程序不知道所需要对象的准确类型
  • 程序需要在多个对象间共享数据

直接管理内存

• 用new动态分配和初始化对象
  • new无法为分配的对象命名（因为自由空间分配的内存是无名的），因此是返回一个指向该对象的指针
  • int *pi = new int(123);
  • 一旦内存耗尽，会抛出类型是bad_alloc的异常
• 用delete将动态内存归还给系统
  • 接受一个指针，指向要释放的对象
  • delete后的指针称为空悬指针（dangling pointer）
• 使用new和delete管理动态内存存在三个常见问题
  • 忘记delete内存
  • 使用已经释放掉的对象
  • 同一块内存释放两次
• 坚持只使用智能指针可以避免上述所有问题

shared_ptr和new结合使用

定义和改变shared_ptr的其他方法

智能指针和异常

• 如果使用智能指针，即使程序块由于异常过早结束，智能指针类也能确保在内存不需要的时候将其释放
• 智能指针陷阱
  • 不用相同的内置指针初始化（或reset）多个智能指针
  • 不delete用get()返回的指针
  • 如果你使用get()返回的指针，记得当最后一个对应的智能指针销毁后，你的指针就无效了
  • 如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器

unique_ptr

• 某一个时刻只能有一个unique_ptr指向一个给定的对象
• 不支持拷贝或者赋值操作
• 向后兼容：auto_ptr：老版本，具有unique_ptr的部分特性。特别是，不能在容器中保存auto_ptr，也不能从函数返回auto_ptr

unique_ptr操作

weak_ptr

• weak_ptr是一种不控制所指向对象生存期的智能指针
• 指向一个由shared_ptr管理的对象，不改变shared_ptr的引用计数
• 一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放，不管有没有weak_ptr指向该对象

weak_ptr操作

动态数组

new和数组

• new一个动态数组
  • 类型名之后加一对方括号，指明分配的对象数目（必须是整型，不必是常量）
  • 返回指向第一个对象的指针
  • int *p = new int[size];
• delete一个动态数组
  • delete [] p;
• unique_ptr和数组
  • 指向数组的unique_ptr不支持成员访问运算符（点和箭头）

1
2

std::shared_ptr<int[]> p(new int[5], [](int *p) { delete []p; });
std::unique_ptr<int[]> p1(new int[5]);

allocator类

• 标准库allocator类定义在头文件memory中，帮助我们将内存分配和对象构造分离开
• 分配的是原始的、未构造的内存
• allocator是一个模板
• allocator<string> alloc;

标准库allocator类及其算法

allocator伴随算法

• 定义在头文件memory中
• 在给定目的位置创建元素，而不是由系统分配内存给他们

实现一个引用计数

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

class HasPtr {
public:
    HasPtr(const std::string &s = std::string()) : ps(new std::string(s)), i(0), use(new size_t(1)) { }
    HasPtr(const HasPtr &hp) : ps(hp.ps), i(hp.i), use(hp.use) { ++*use; }
    HasPtr& operator=(const HasPtr &rhs) {
        ++*rhs.use;
        if (--*use == 0) {
            delete ps;
            delete use;
        }
        ps = rhs.ps;
        i = rhs.i;
        use = rhs.use;
        return *this;
    }
    ~HasPtr() {
        if (--*use == 0) {
            delete ps;
            delete use;
        }
    } 
private:
    std::string *ps;
    int i;
    size_t *use;
};

• 关联容器和顺序容器的不同：关联容器中的元素时按照关键字来保存和访问的
• 关联容器支持通过关键字来高效地查找和读取元素，基本的关联容器类型是 map和 set

关联容器类型

关联容器概述

定义关联容器

• 需要指定元素类型
• 列表初始化：
  • map：map<string, int> word_count = {{"a", 1}, {"b", 2}};
  • set：set<string> exclude = {"the", "a"};

关键字类型的要求

• 对于有序容器，关键字类型必须定义元素比较的方法。默认是<
• 如果想传递一个比较的函数，可以这样定义：multiset<Sales_data, decltype(compareIsbn)*> bookstore(compareIsbn);

pair

• 在utility头文件中定义
• 一个pair保存两个数据成员，两个类型不要求一样

pair的操作：

关联容器操作

关联容器额外的类型别名

关联容器迭代器

• 解引用一个关联容器迭代器时，会得到一个类型为容器的value_type的值的引用
• set的迭代器是const的
• 遍历关联容器：使用begin和end，遍历map、multimap、set、multiset时，迭代器按关键字升序遍历元素

添加元素

关联容器insert操作

向map添加元素：

• word_count.insert({word, 1});
• word_count.insert(make_pair(word, 1));
• word_count.insert(pair<string, size_t>(word, 1));
• word_count.insert(map<string, size_t>::value_type (word, 1));

删除元素

从关联容器中删除元素

下标操作

map和unordered_map的下标操作

查找元素

在一个关联容器中查找元素

• lower_bound和upper_bound不适用于无序容器
• 下标和at操作只适用于非const的map和unordered_map

无序容器

• 有序容器使用比较运算符来组织元素；无序容器使用哈希函数和关键字类型的==运算符
• 理论上哈希技术可以获得更好的性能
• 无序容器在存储上组织为一组桶(bucket)，每个桶保存零个或多个元素。无序容器使用一个哈希函数将元素映射到桶

无序容器管理操作

泛型算法

• 因为它们实现共同的操作，所以称之为“算法”；而“泛型”、指的是它们可以操作在多种容器类型上
• 泛型算法本身不执行容器操作，只是单独依赖迭代器和迭代器操作实现
• 头文件： #include <algorithm>或者 #include <numeric>(算数相关)
• 大多数算法是通过遍历两个迭代器标记的一段元素来实现其功能
• 必要的编程假定：算法永远不会直接改变底层容器的大小。算法可能通过迭代器改变容器中保存的元素的值、移动元素、插入元素，但不能直接添加或者删除元素

find

• vector<int>::const_iterator result = find(vec.begin(), vec.end(), search_value);
• 输入：两个标记范围的迭代器和目标查找值。返回：如果找到，返回对应的迭代器，否则返回第二个参数，即标记结尾的迭代器

1
2
3
4
5

std::vector<int> vec = {1, 2, 3, 4, 5};
const auto iter = std::find(vec.cbegin(), vec.cend(), 3);
if (iter != vec.end()) {
    std::cout << "find" << *iter <<  std::endl;
}

初识泛型算法

• 标准库提供了超过100个算法，但这些算法有一致的结构
• 理解算法的最基本的方法是了解它们是否读取元素、改变元素、重排元素顺序

只读算法

• 只读取范围中的元素，不改变元素
• 如 find和 accumulate（在numeric中定义，求和）
• find_first_of，输入：两对迭代器标记两段范围，在第一段中找第二段中任意元素，返回第一个匹配的元素，找不到返回第一段的end迭代器
• 通常最好使用cbegin和cend
• equal：确定两个序列是否保存相同的值

写容器元素的算法

• 一些算法将新值赋予序列中的元素
• 算法不检查写操作
• fill： fill(vec.begin(), vec.end(), 0); 将每个元素重置为
• fill_n： fill_n(vec.begin(), 10, 0);
• 插入迭代器back_inserter
  • 用来确保算法有足够的空间存储数据
  • #include <iterator>
  • back_inserter(vec)
• 拷贝算法copy
• 输入：前两个参数指定输入范围，第三个指向目标序列
• copy (ilst.begin(), ilst.end(), back_inserter(ivec));
• copy时必须保证目标目的序列至少要包含与输入序列一样多的元素`

1
2
3

std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> vecnew(5);
copy(vec.cbegin(), vec.cend(), vecnew.begin());

重排容器元素的算法

• 这些算法会重排容器中元素的顺序
• 排序算法sort
  • 接受两个迭代器，表示要排序的元素范围
• 消除重复unique
  • 之前要先调用sort
  • 返回的迭代器指向最后一个不重复元素之后的位置
  • 顺序会变，重复的元素被“删除”
  • 并没有真正删除，真正删除必须使用容器操作

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

bool descend(int a, int b) {
    return a < b;
}

int main(int argc, char const *argv[])
{
    std::vector<int> vec = {5, 5, 3, 2, 2, 1};
    std::sort(vec.begin(), vec.end(), descend);

    auto end = unique(vec.begin(), vec.end());

    vec.erase(end, vec.end());

    for (auto &i : vec) {
        std::cout << i << std::endl;
    }
}

定制操作

向算法传递函数

• 谓词（predicate）

  • 是一个可调用的表达式，返回结果是一个能用作条件的值
  • 一元谓词：接受一个参数
  • 二元谓词：接受两个参数

• 例子：

  • stable_sort：
    • 保留相等元素的原始相对位置
    • stable_sort(words.begin(), words.end(), isShorter);

lambda表达式

• 有时可能希望操作可以接受更多的参数

• lambda表达式表示一个可调用的代码单元，可以理解成是一个未命名的内联函数

• 形式：[capture list](parameter list) -> return type {function body}

  • 其中capture list捕获列表是一个lambda所在函数定义的局部变量的列表（通常为空）。不可忽略
  • return type是返回类型。可忽略
  • parameter是参数列表。可忽略
  • function body是函数体。不可忽略
  • auto f = [] {return 42;}

• 例子：

  • find_if
    • 接受一对表示范围的迭代器和一个谓词，用来查找第一个满足特定要求的元素。返回第一个使谓词返回非0值的元素
    • auto wc = find_if(words.begin(), words.end(), [sz](const string &a){return a.size() >= sz;});
  • for_each
    • 接受一个可调用对象，并对序列中每个元素调用此对象
    • for_each(wc, words.end(), [](const string &s){cout << s << " ";})

lambda捕获和返回

• 定义lambda时会生成一个新的类类型和该类型的一个对象
• 默认情况下，从lambda生成的类都包含一个对应该lambda所捕获的变量的数据成员，在lambda对象创建时被初始化
• 值捕获：前提是变量可以拷贝，size_t v1 = 42; auto f = [v1] {return v1;};
• 引用捕获：必须保证在lambda执行时，变量是存在的，auto f2 = [&v1] {return v1;};
• 尽量减少捕获的数据量，尽可能避免捕获指针或引用
• 隐式捕获：让编译器推断捕获列表，在捕获列表中写一个&（引用方式）或=（值方式）。auto f3 = [=] {return v1;}

lambda捕获列表

参数绑定

• lambda表达式更适合在一两个地方使用的简单操作
• 如果是很多地方使用相同的操作，还是需要定义函数
• 函数如何包装成一元谓词？使用参数绑定
• 标准库bind函数：
  • 定义在头文件functional中，可以看做为一个通用的函数适配器
  • auto newCallable = bind(callable, arg_list);
  • 我们再调用newCallable的时候，newCallable会调用callable并传递给它arg_list中的参数
  • _n代表第n个位置的参数。定义在placeholders的命名空间中。using std::placeholder::_1;
  • auto g = bind(f, a, b, _2, c, _1);，调用g(_1, _2)实际上调用f(a, b, _2, c, _1)
  • 非占位符的参数要使用引用传参，必须使用标准库ref函数或者cref函数

再探迭代器

插入迭代器

• 插入器是一种迭代器适配器，接受一个容器，生成一个迭代器，能实现向给定容器添加元素
• 三种类型：
  • back_inserter：创建一个使用push_back的迭代器
  • front_inserter创建一个使用push_front的迭代器
  • inserter创建一个使用insert的迭代器。接受第二个参数，即一个指向给定容器的迭代器，元素会被查到迭代器所指向的元素之前

插入迭代器操作

iostream迭代器

• 迭代器可与输入或输出流绑定在一起，用于迭代遍历所关联的IO流
• 通过使用流迭代器，我们可以用泛型算法从流对象中读取数据以及向其写入数据

istream_iterator的操作

ostream_iterator的操作

反向迭代器

• 反向迭代器就是在容器中从尾元素向首元素反向移动的迭代器
• 对于反向迭代器，递增和递减的操作含义会颠倒
• 实现向后遍历，配合rbegin和rend

泛型算法结构

5类迭代器

算法的形参模式

• alg(beg, end, other args);
• alg(beg, end, dest, other args);
• alg(beg, end, beg2, other args);
• alg(beg, end, beg2, end2, other args);

其中，alg是算法名称，beg和end表示算法所操作的输入范围。dest、beg2、end2都是迭代器参数，是否使用要依赖于执行的操作

算法命名规范

• 一些算法使用重载形式传递一个谓词
• 接受一个元素值的算法通常有一个不同名的版本：加_if，接受一个谓词代替元素值
• 区分拷贝元素的版本和不拷贝的版本：拷贝版本通常加_copy

特定容器算法

• 对于list和forward_list，优先使用成员函数版本的算法而不是通用算法

list和forward_list成员函数版本的算法

• 上面的操作都返回void

list和forward_list的splice成员函数版本的参数

• 使用lst.splice(args)或flst.splice_after(args)

顺序容器概述

• 顺序容器（sequential container）：为程序员提供了控制元素存储和访问顺序的能力。这种顺序不依赖于元素的值，而是与元素加入容器时的位置相对应

顺序容器类型

• 除了固定大小的array外，其他容器都提供高效、灵活的内存管理
• forward_list和array是新C++标准增加的类型
• 通常使用vector是最好的选择，除非你有很好的理由选择其他容器
• 新标准库的容器比旧版的快得多

容器操作

类型

构造函数

• 只有顺序容器的构造函数才接受大小参数，关联容器并不支持
• array具有固定大小
• 和其他容器不同，默认构造的array是非空的
• 直接复制：将一个容器复制给另一个容器时，类型必须匹配：容器类型和元素类型都必须相同
• 使用迭代器复制：不要求容器类型相同，容器内的元素类型也可以不同

赋值和swap

• 使用非成员版本的swap是一个好习惯
• assign操作不适用于关联容器和array

大小

添加元素

• 因为这些操作会改变大小，因此不适用于array
• forward_list有自己专有版本的insert和emplace
• forward_list不支持push_back和emplace_back
• 当我们用一个对象去初始化容器或者将对象插入到容器时，实际上放入的是对象的拷贝
• emplace开头的函数是新标准引入的，这些操作是构造而不是拷贝元素
• 传递给emplace的参数必须和元素类型的构造函数相匹配

访问元素

• 访问成员函数返回的是引用
• at和下标操作只适用于string、vector、deque、array
• back不适用于forward_list
• 如果希望下标是合法的，可以使用at函数

删除元素

• 会改变容器大小，不适用于array
• forward_list有特殊版本的erase
• forward_list不支持pop_back
• vector和string不支持pop_front

特殊的forwad_list操作

• 链表在删除元素时需要修改前置节点的内容，双向链表会前驱的指针，但是单向链表没有保存，因此需要增加获取前置节点的方法
• forward_list定义了before_begin，即首前（off-the-begining）迭代器，允许我们再在首元素之前添加或删除元素

改变容器大小

获取迭代器

• 以c开头的版本是C++11新标准引入的
• 当不需要写访问时，应该使用cbegin和cend。

反向容器的额外成员

• 不支持forward_list

迭代器

• 迭代器范围：begin到end，即第一个元素到最后一个元素的后面一个位置
• 左闭合区间：[begin, end)
• 左闭合范围蕴含的编程设定：
  • 如果begin和end相等，则范围为空
  • 如果二者不等，则范围至少包含一个元素，且begin指向该范围中的第一个元素
  • 可以对begin递增若干次，使得begin == end

容器操作可能使迭代器失效

• 在向容器添加元素后：
  • 如果容器是vector或string，且存储空间被重新分配，则指向容器的迭代器、指针、引用都会失效。如果存储空间未重新分配，指向插入位置之前的元素的迭代器、指针和引用仍有效，但指向插入位置之后元素的迭代器、指针和引用将会失效
  • 对于deque，插入到除首尾位置之外的任何位置都会导致指向容器的迭代器、指针、引用失效。如果在首尾位置添加元素，迭代器会失效，但指向存在元素的引用和指针不会失效
  • 对于list和forward_list，指向容器的迭代器（包括尾后迭代器和首前迭代器）、指针和引用依然有效
• 在从一个容器中删除元素后：
  • 指向被删除元素的迭代器、指针和引用会失效
  • 对于list和forward_list，指向容器其他位置的迭代器、引用和指针仍然有效
  • 对于deque，如果在首尾之外的任何位置删除元素，那么指向被删除元素外其他元素的迭代器、指针、引用都会失效；如果是删除deque的尾元素，则尾后迭代器会失效，但其他不受影响；如果删除的是deque的头元素，这些也不会受影响。
  • 对于vector和string，指向被删元素之前的迭代器、引用、指针仍然有效
  • 注意：当我们删除元素时，尾后迭代器总是会失效
  • 注意：使用失效的迭代器、指针、引用是严重的运行时错误
  • 建议：将要求迭代器必须保持有效的程序片段最小化
  • 建议：不要保存end返回的迭代器
  • 建议：每次改变容器的操作之后都正确地重新定位迭代器

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

std::vector<int> arr = {1, 2, 3 ,4 ,5};
auto iter = arr.begin();

while (iter != arr.end()) { //每次都重新计算end
    if (*iter == 1) {
        iter = arr.insert(iter, 0); //iter指向0
        iter += 2; //跳过0，1, iter指向3
    } else if (*iter == 5) {
        iter = arr.erase(iter); //iter == end
    } else {
        iter++;
    }
}

容器内元素的类型约束

• 元素类型必须支持赋值运算
• 元素类型的对象必须可以复制
• 除了输入输出标准库类型外，其他所有标准库类型都是有效的容器元素类型

vector对象是如何增长的

vector和string在内存中是连续保存的，如果原先分配的内存位置已经使用完，则需要重新分配新空间，将已有元素从就位置移动到新空间中，然后添加新元素

管理容量的成员函数

• shrink_to_fit只适用于vector、string和deque
• capacity和reverse只适用于vector和string

额外的string操作

构造string的其他方法

• n,len2,pos2都是无符号值

substr操作

改变string的其他方法

string搜索操作

• string类提供了6个不同的搜索函数，每个函数都有4个重载版本
• 每个搜索操作都返回一个string::size_type值，表示匹配发生位置的下标。如果搜索失败则返回一个名为string::npos的static成员（类型是string::size_type，初始化值是-1，也就是string最大的可能大小）

args必须是一下的形式之一：

s.compare的几种参数形式

逻辑类似于C标准库的strcmp函数，根据s是等于、大于还是小于参数指定的字符串，s.compare返回0、正数或负数。

string和数值转换

容器适配器（adapter）

• 适配器是使一事物的行为类似于另一事物的行为的一种机制，例如stack可以使任何一种顺序容器以栈的方式工作
• 初始化 deque<int> deq; stack<int> stk(deq); 从deq拷贝元素到stk
• 创建适配器时，指定一个顺序容器，可以覆盖默认的基础容器： stack<string, vector<string> > str_stk;

适配器的通用操作和类型

stack

• 定义在stack头文件中
• stack默认基于deque实现，也可以在list或vector之上实现

queue和priority_queue

• 定义在queue头文件中
• queue默认基于deque实现，priority_queue默认基于vector实现
• queue可以在list或vector之上实现，priority_queue也可以用deque实现

前面章节已经在用的IO库设施

• istream：输入流类型，提供输入操作
• ostream：输出流类型，提供输出操作
• cin：一个istream对象，从标准输入读取数据
• cout：一个ostream对象，向标准输出写入数据
• cerr：一个ostream对象，向标准错误写入消息
• >>运算符：用来从一个istream对象中读取输入数据
• <<运算符：用来向一个ostream对象中写入输出数据
• getline函数：从一个给定的istream对象中读取一行数据，存入到一个给定的string对象中

IO类

标准库定义的IO类型

• iostream头文件：从标准流中读写数据，istream、ostream等。
• fstream头文件：从文件中读写数据，ifstream、ofstream等。
• sstream头文件：从字符串中读写数据，istringstream、ostringstream

IO对象不可复制或赋值

• 1.IO对象不能存在容器里
• 2.形参和返回类型也不能是流类型
• 3.形参和返回类型一般是流的引用
• 4.读写一个IO对象会改变其状态，因此传递和返回的引用不能是const的

条件状态

上表中，strm是一种IO类型，（如istream）， s是一个流对象

管理输出缓冲

• 每个输出流都管理一个缓冲区，执行输出的代码，文本串可能立即打印出来，也可能被操作系统保存在缓冲区内，随后再打印
• 刷新缓冲区，可以使用如下IO操纵符：
  • endl：输出一个换行符并刷新缓冲区
  • flush：刷新流，单不添加任何字符
  • ends：在缓冲区插入空字符null，然后刷新
  • unitbuf：告诉流接下来每次操作之后都要进行一次flush操作
  • nounitbuf：回到正常的缓冲方式

文件输入输出

• 头文件fstream定义了三个类型来支持文件IO：
  • ifstream从一个给定文件读取数据
  • ofstream向一个给定文件写入数据
  • fstream可以读写给定文件
• 文件流：需要读写文件时，必须定义自己的文件流对象，并绑定在需要的文件上

fstream特有的操作

上表中，fstream是头文件fstream中定义的一个类型，fstrm是一个文件流对象

文件模式

string流

• 头文件sstream定义了三个类型来支持内存IO：
  • istringstream从string读取数据
  • ostringstream向string写入数据
  • stringstream可以读写给定string

stringstream特有的操作

上表中sstream是头文件sstream中任意一个类型。s是一个string