面向对象程序设计基于三个基本概念：数据抽象、继承和动态绑定。通过数据抽象，可以将类的接口与实现分离；使用继承，可以定义相似的类型并对其相似关系建模；使用动态绑定，可以在一定程度上忽略相似类型的区别，从而以统一的方式使用它们的对象。

定义基类和派生类

定义基类

在C++语言中，当我们使用基类的引用或者指针调用一个虚函数时将发生动态绑定，即在运行时选择函数的版本。
基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此。因为在C++中，当派生类对象经由一个基类对象指针被删除，而该基类带有一个非虚析构函数，那么基类成分将被销毁，而派生类对象的析构函数未被执行，从而造成“局部销毁”对象。
是否应该声明virtual析构函数的原则：

如果类带有任何virtual函数，它就应该拥有一个virtual析构函数
如果类设计的目的不是作为基类使用，或者不是为了具备多态性，就不该声明virtual析构函数

基类通过在其成员函数的声明语句之前加上关键字virtual使得该函数执行动态绑定。关键字virtual仅出现在声明处而不能用于类外部的函数定义。在基类中为virtual函数，则该函数在派生类中隐式地也是虚函数。

当运算符作用于类类型的运算对象时，可以通过运算符重载重新定义该运算符的含义。合理使用运算符重载能令我们的程序更易于编写和阅读。

基本概念

重载的运算符是具有特殊名字的函数：它们的名字由关键字operator和其后要定义的运算符号共同组成。除了重载的函数调用运算符operator()之外，其他重载运算符不能含有默认实参。
当一个重载的运算符是成员函数时，则它的第一个(左侧)运算对象绑定到隐式的this指针上。
对于一个运算符函数来说，它或者是类的成员，或者至少包含有一个类类型的参数，因此我们不能改变内置类型的运算符的含义。
我们可以使用直接和间接两种方式调用重载的运算符函数：

1
2
3
4
5
6
7

//非成员运算符函数的等价调用
data1 + data2;  //普通的表达式
operator+(data1, data2); //等价的函数调用

//调用成员函数的operator+=运算符
data1 += data2; //this绑定到data1的地址、将data2作为实参传入函数
data1.operator+=(data2);  

通常情况下，不应该重载逗号、取地址、逻辑与和逻辑或运算符。
当内置的运算符和我们自己的操作之间存在逻辑映射关系时，使用重载的运算符更自然直观。但是，过分滥用运算符重载也会使我们的类变得难以理解。

拷贝控制决定着对象在拷贝、移动、赋值和销毁时的行为，包括：拷贝构造函数(copy constructor)、拷贝赋值运算符(copy-assignment operator)、移动构造函数(move constructor)、移动赋值运算符(move-assignment operator)和析构函数(destructor)。

拷贝构造和移动构造函数定义当用同类型的另一个对象初始化本对象时做什么。
拷贝赋值运算符和移动赋值运算符定义了将一个对象赋予同类型对象时做什么。
析构函数定义了当此对象销毁时做什么。

拷贝、赋值和销毁

拷贝构造函数

拷贝构造函数特征：首先满足构造函数特征，没有返回值；其次操作函数的第一个参数必须是自身类型的引用，其他参数有默认值。
如果第一个参数不是引用类型，为了在调用拷贝构造函数时拷贝实参又需要调用拷贝构造函数，从而形成死循环。

拷贝赋值运算符

赋值运算符其实就是名为operator=的函数。赋值运算符通常应该返回一个指向其左侧对象的引用。

析构函数

如同构造函数有一个初始化部分和一个函数体，析构函数也有一个函数体和一个析构部分。在构造函数中，成员的初始化是在函数体执行之前完成的，而且按照它们在类中出现的顺序初始化。在析构函数中，首先执行函数体，然后按初始化的相反顺序销毁其成员。成员是在析构函数体之后隐含的析构阶段中被销毁的。
对于一个类，只有唯一的一个析构函数。

动态对象的生存期由程序来控制，当动态对象不再使用时，程序必须显式地销毁它们。

动态内存与智能指针

C++11新标准库提供两种智能指针类型管理动态对象。智能指针行为类似常规指针，重要区别是智能指针负责自动释放所指向的对象。两种智能指针的区别在于管理底层底层的方式：shared_ptr允许多个指针指向同一个对象；unique_ptr则独占所指向的对象。标准库还定义了一个名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象。三种类型都定义在memory头文件中。

shared_ptr类

智能指针也是模板类，必须在尖括号内提供指针指向的类型参数。
shared_ptr和unique_ptr都支持的操作

1
2
3
4
5
6
7
8

shared_ptr<T>    空智能指针，可以指向类型为T的对象
unique_ptr<T>
p                将p用作一个条件判断，若p指向一个对象，则为true
*p               解引用p，获得它指向的对象
p->mem           等价于(*p).mem
p.get()          返回p中保存的指针。小心使用，若智能指针释放了其对象，返回的指针所指向的对象也就消失
swap(p, q)       交换p和q中的指针
p.swap(q)

shared_ptr独有的操作

1
2
3
4
5
6

make_shared<T>(args)   返回一个shared_ptr，指向一个动态分配的类型为T的对象。使用args初始化此对象
shared_ptr<T> p(q)     p是shared_ptr的拷贝；此操作会递增q中的计数器。q中的指针必须能转换为T*
p = q                  p和q都是shared_ptr，所保存的指针必须能相互转换。此操作会递减p的引用计数，
                       递增q的引用。若p的引用计数变为0，则将其管理的原内存释放。表达式含义：将p指向q的对象
p.unique()             若p.use_count()为1，则返回true；否则返回false
p.use_count()          返回与p共享对象的智能指针数量，可能很慢，主要用于调试

关联容器中的元素是按关键字来保存和访问的，支持高效的关键字查找和访问。标准库提供8个关联容器，体现在3个维度：
(1) set或者map；(2)关键字能否重复，允许重复关键字的包含单词multi；(3)按顺序保存或无序保存，不保持关键字按顺序存储的容器的名字都以单词unordered开头。因此，unordered_multi_set是一个允许关键字重复，元素无序保存的集合，而set则是一个要求关键字不重复，有序存储的集合。set和map使用红黑树，无序容器使用哈希函数来组织元素。
关联容器类型：

按关键字有序保存元素
map
set
multimap
multiset
无序集合
unordered_map
unordered_set
unordered_multimap
unordered_multiset

使用关联容器

在忽略大小写和标点的单词计数程序中，首先是对输入的字符串进行处理，剔除单词中的标点，并将大写转换成小写。

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

string &trans(string &s)
{
    for(string::size_type p = 0; p < s.size(); ++p)
    {
        if(s[p] >= 'A' && s[p] <= 'Z')
        {
            s[p] -= ('A' - 'a');
        }
        else if(s[p] == ',' || sp[p] == '.')
        {
            s.erase(p, 1);
        }
    }
    return s;
}

关联容器概述

关联容器的迭代器都是双向的。在C++11新标准中，我们可以对关联容器进行值初始化：

1
2
3
4
5

map<string, size_t> word_count; //空容器
//列表初始化
set<string> exclude = {"the", "but", "and", "or", "an"};
//三个元素：authors将姓映射为名
map<string, string> authors = {{"Joyce", "James"}, {"Austen", "Jane"}, {"Dickens, "Charles"}};

标准库并未给容器添加大量的功能，而是提供了一组独立于任何特定容器的通用的算法实现相关功能。算法是泛型的，也就是说可以用于不同类型的元素和多种容器类型，不仅包括标准库类型，还包括内置数组类型。

概述

大多数算法定义在头文件algorithm中。标准库还在头文件numeric中定义了一组数值泛型算法。算法并不直接操作容器，而是遍历由两个迭代器指定的一个元素范围进行操作。迭代器令算法不依赖于容器，但算法依赖于元素类型的操作，大多数算法提供了一种方法，允许我们使用自定义的操作来代替默认的运算符。STL组件间关系如下图所示：

初识泛型算法

算法使用元素的方式包括只读取元素、改变元素或者是重排元素顺序。算法不会执行容器操作，所以算法不会改变底层容器的大小。

只读算法

accumulate的第三个参数的类型决定了函数中使用哪个加法运算符以及返回值的类型。

1
2
3
4
5
6

//对vec中的int元素求和，和的初始值为0
int sum = accumulate(vec.cbegin(), vec.cend(), 0);
//将vector中所有的string元素连接起来
string sum = accumulate(v.cbegin(), v.cend(), std::string(""));
//错误：const char*上没有定义+运算符
string sum = accumulate(v.cbegin(), v.cend(), "");

对于只读取元素而不改变元素的算法，最好使用cbegin()和cend()。
使用equal判断两个序列是否保存相同的值，构成这两个序列的元素可以来自不同类型的容器。

1
2
3

vector<string> roster1 = {"Hello", "The", "a"};
list<const char*> roster2 = {"Hello", "The", "a"};
bool eq = equal(roster1.cbegin(), roster1.cend(), roster2.cbegin());

在上面equal中，如果roster中都是C风格字符串，用==比较两个char*对象，只是检查两个指针值是否相等。所以只有当两个序列中的指针都指向相同地址时，equal才会返回true。否则，即使字符串内容完全相同，也会返回false。
那些只接受一个单一迭代器来表示第二个序列的算法，都假定第二个序列至少与第一个序列一样长。

顺序容器概述

顺序容器中顺序不依赖元素的值，而与元素加入容器时的位置相对应。所有顺序容器都提供快速顺序访问元素的能力，但在以下方面有不同的性能折中：

向容器中添加和删除元素的代价
非顺序访问容器中元素的代价

顺序容器类型

1
2
3
4
5
6

vector        可变大小数组。支持快速随机访问。在尾部之外的位置插入或删除元素可能很慢
deque         双端队列。支持快速随机访问。在头尾位置插入、删除速度都很快
list          双向链表。只支持双向顺序访问。在list中任何位置进行插入、删除操作速度都很快
forward_list  单向链表。只支持单向顺序访问。在链表任何位置进行插入、删除操作速度都很快
array         固定大小数组。支持快速随机访问。不能添加或删除元素
string        与vector相似的容器，但专门用于保存字符。随机访问快。在尾部插入、删除速度快

新标准库容器的性能几乎肯定与最精心优化过的同类数据结构一样好(通常会更好)。现代C++程序应该使用标准库容器，而不是更原始的数据结构，如内置数组。

选择容器的基本原则

1）除非有很好的理由选择其他容器，否则应使用vector；
2）如果程序有很多小元素，且空间的额外开销很重要，则不要使用list或forward_list；
3）如果程序要求随机访问元素，应使用vector或deque；
4）如果程序要求在容器的中间插入或删除元素，应使用list或forward_list；
5）如果程序需要在头尾位置插入或删除元素，但不会在中间位置进行插入或删除操作，则使用deque；
6）如果程序只有在读取输入时才需要在容器中间位置插入元素，随后需要随机访问元素，则:
- 首先，确定是否真的需要在容器中间位置添加元素。当处理输入数据时，通常可以很容易地向vector追加数据，然后在调用标准库的sort函数来重排序，从而避免在中间位置添加元素。
- 如果必须在中间位置插入元素，考虑在输入阶段使用list，一旦输入完成，将list中的内容拷贝到一个vector中。

如果不确定应该使用哪种容器，那么在程序中使用vector和list公共操作：使用迭代器，不使用下标访问，避免随机访问。这样，在必要时选择使用vector和list都很方便。

IO类

标准库定义的IO类型包括基础istream，ostream，iostream类型，ifstream，ofstream，fstream读写文件类型以及istringstream，ostringstream，stringstream读写内存string对象的类型。
另外，为了支持使用宽字符，标准库还定义了一组wchar_t类型的数据。
宽字符版本的类型和函数的名字以一个w开始。例如：wiostream，wfstream，wstringstream，wcin，wcout，wcerr。

IO类型间的关系

继承机制让我们可以将派生类对象当作基类对象来使用。类型ifstream和istringstream都继续自istream。因此，我们可以在传递istream对象的地方传递ifstream和istringstream。
例如：对ifstream和istringstream对象调用getline，也可以用>>从ifstream和istringstream读取数据。类的ofstream和ostringstream也都继承自ostream。

IO对象无拷贝和赋值

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

条件状态

IO类定义了一些函数和标志，帮助我们访问和控制流的状态条件。IO标准库内部条件状态：

1
2
3
4
5

strm::iostate  由各个iostream 类定义，用于定义条件状态
strm::badbit   strm::iostate类型的值，用于指出被破坏的流
strm::failbit  strm::iostate类型的值，用于指出失败的流
strm::eofbit   strm::iostate类型的值，用于指出流已经到达文件的结束符
strm::goodbit　strm::iostate类型的值，流未出现错误状态，此值保证为0

IO标准库条件状态获取以及设置函数：

1
2
3
4
5
6
7
8

s.eof()           若流s的eofbit置位，则返回true
s.fail()          若流s的failbit或badbit置位，则返回true
s.bad()           若流s的badbit置位，则返回true
s.good()          若流s处于有效状态，则返回true
s.clear()         将流s的所有条件状态位复位，将流的状态设置为有效
s.clear(flag)     根据指定的flag，将流s中对应条件状态复位。flag类型是strm::iostate
s.setstate(flag)  根据指定的flag，将流s中对应条件状态置位
s.rdstate()       返回流的当前条件状态，返回值类型是strm::iostate

使用位操作按需复位生成新的状态，例如将failbit和badbit复位，但保持eofbit不变：

1

cin.clear(cin.rdstate() & ~cin.failbit & ~cin.badbit)

在C++中，我们可以使用类定义自己的数据类型，用新的类型反映程序中的概念，从而我们更容易编写、调试和修改程序。
类的基本思想是数据抽象和封装。数据抽象能够帮助我们将对象的具体实现和对象所执行的操作分离开来，是一种依赖于接口和实现分离的编程技术。封装后的类隐藏了实现细节，类的使用者只需要使用接口而不需要关心具体的实现，降低程序的耦合性。

定义抽象数据类型

成功的应用程序，作者必须充分了解并实现用户的需求。所以，优秀的类设计者也应该密切关注那些使用该类的程序员的需求。作为一个设计良好的类，既要有直观而且易于使用的接口，也要具备高效的实现过程。
定义在类内部的函数是隐式的inline函数。

引入this

当我们调用成员函数时，实际上是在替某个对象调用它。成员函数通过一个名为this的隐式参数来访问调用它的对象。当我们调用一个成员函数时，用调用该函数对象的地址初始化this。例如，调用total.isbn()，则编译器负责把total的地址传递isbn的隐式参数this，等价于编译器将调用重写成如下形式：

1
2

//伪代码，用于说明调用成员函数的实际执行过程
Sales_data::isbn(&total);

在成员函数内部，因为this都指向该对象，所以可以直接调用该对象的其他成员函数。
this形参是隐式定义的。所以，任何自定义名为this的参数或成员变量都是非法的。另外，我们可以在成员函数内部使用this。因为this的目的总是指向“这个”对象，所以this是一个常量指针。

函数基础

局部对象

自动对象

只存在于块执行期间的对象称为自动对象，当块执行结束后，块中创建的自动对象的值就变成未定义的了。
形参是一种自动对象，函数开始时为形参申请存储空间，位于CPU寄存器或者栈上；函数执行结束后，形参销毁。

局部静态对象

如果需要函数的局部变量在函数调用以及之后时间有效，可以将局部变量定义成static类型。局部静态对象(local static object)在程序第一次经过对象时初始化，并且直到程序终止才被销毁。初始化的局部静态对象存储在.data段，如果局部静态变量没有显式的初始值，它将执行值初始化，内置类型的局部静态变量初始化为0。

参数传递

每次调用函数时都会重新创建它的形参，并用传入的实参对形参进行初始化。
形参初始化的机制和变量初始化一样。

• 当形参为引用类型时，它将绑定到对应的实参上，也就是说引用形参是对应实参的别名
• 传值调用时，形参和实参是两个相互独立的对象，实参的值被拷贝给形参，因此函数对形参做的修改不会影响实参

当拷贝大的类类型或者容器对象时效率低或者有些类型不支持拷贝，可以使用引用避免拷贝。如果函数不改变引用形参的值，最好将其声明为常量引用
一个函数只能返回一个值，但有时我们需要同时返回多个值，可以使用返回结构体形式或者使用引用形参。

数组形参

因为数组会被转换成指针，所以当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。所以，调用者需要提供额外的信息：

• 使用标记指定数组的长度，例如C风格字符串结尾的空字符，空字符指ASCII值为0的控制字符，在程序代码中通常以转义序列’\0’表示
• 使用标准库规范，同时传递首元素和尾后元素指针 void print(const int *beg, const int *end)
• 显式传递一个表示数组大小的形参