C++ 学习笔记——十、标准模板库
目录：点我
一、智能指针模板类
智能指针是行为类似于指针的类对象，但这种对象还有其他功能，下面介绍三个可帮助管理动态内存分配的智能指针模板：
void remodel(string & str) {
string * ps = new string(str);
...
str = *ps;
return;
}
对于上面的函数，每当调用时，该函数都分配堆中的内存，但从不收回，导致内存泄漏，只需在 return 前添加 delete ps 即可释放内存。但是通常会忘记这一步，而且如果存在其他异常情况导致没有执行它，也会导致内存泄漏：
void remodel(string & str) {
string * ps = new string(str);
...
if(weird_thing()) // 可能由于抛出异常导致未执行内存泄漏
throw exception();
str = *ps;
delete ps;
return;
}
遇到这种情况，就期望指针 ps 是一个对象，这样当它过期时就可以使用析构函数删除指向的内存，为此 C++ 提供了智能指针模板，其中 auto_ptr 是 C++ 98 提供的方案，C++ 11 已将其摒弃，并提供了另外两种：unique_ptr, shared_ptr ，它们都定义了类似指针的对象，可以将 new 获得的地址赋给它，并且当智能指针过期时，这些内存将自动被释放。
要创建智能指针对象，必须包含头文件 memory ，然后使用通常的模板语法来实例化所需类型的指针：
template<class X> class auto_ptr {
public:
explicit auto_ptr(X* p = 0) throw(); // 必须包含这个构造函数
...
}
auto_ptr<double> pd(new double); // double类型的智能指针
auto_ptr<string> pd(new string); // string类型
unique_ptr<double> pdu(new double); // 相似的用法
shared_ptr<string> pss(new string); // 相似的用法
从写 remodel 方法：
#include 注意，智能指针模板位于名称空间 std 中，下面是一个使用例子：
class Report {
private:
string str;
public:
Report(const string s) : str(s) {cout << "created\n";}
~Report() {cout << "deleted\n";}
void comment() const {cout << str << endl;}
};
int main() {
{
auto_ptr<Report> ps(new Report("auto_ptr"));
ps->comment();
}
{
shared_ptr<Report> ps(new Report("shared_ptr"));
ps->comment();
}
{
unique_ptr<Report> ps(new Report("unique_ptr"));
ps->comment();
}
}
// outputs
created
auto_ptr
deleted
created
shared_ptr
deleted
created
unique_ptr
deleted
所有智能指针都有一个 explicit 构造函数，它将指针作为参数，因此不需要自动将指针转换为智能指针对象。
需要避免下面这种情况：
string v("example");
shared_ptr<string> p(&v);
当 p 过期时，程序将把 delete 运算符用于非堆栈内存，这是错误的。
相同智能指针之间赋值也需要注意：
auto_ptr<string> pa(new string("example")), pb;
pb = pa;
这样做会导致两个指针指向同一个内存，然后当它们相继过期时会对其进行两次 delete ，解决方法有多种：
- 定义赋值运算符：使之成为深复制，即再创建一个副本，使两个指针指向不同的副本；
- 建立所有权概念：对于特定的对象，只有一个智能指针可拥有它，这样只有拥有对象的智能指针的析构函数会删除该对象。然后让赋值操作转让所有权。unique_ptr 和 auto_ptr 采用此策略，但前者更严格；
- 创建智能更高的指针，根据引用特定对象的智能指针数，这称为引用计数（reference counting）。shared_ptr 采用此策略。
下面举一个不适用于 auto_ptr 的例子：
auto_ptr<string> p1(new string("example")), p2;
p2 = p1; // p1丧失所有权
cout << *p1; // 发生错误：Segmentation fault (core dumped)
由于 p1 丧失所有权，因此变成一个空指针，此时访问 p1 发生错误；如果采用 shared_ptr 则能正常工作，因为二者都指向同一块区域；如果采用 unique_ptr 则会在编译过程中察觉错误，因此这样更安全。
再来看下一种情况：
unique_ptr<string> demo(const string s) {
unique_ptr<string> tmp(new string(s));
return tmp;
}
unique_ptr<string> ps = demo("example");
此时由于 demo 函数返回一个临时的 unique_ptr ，然后 ps 接管了原本返回的 unique_ptr 所有的对象，而返回的 unique_ptr 被销毁，这没有问题，因为 ps 拥有了 string 对象的所有权。这样做的另一个好处是 demo 函数返回的临时 unique_ptr 很快被销毁，没有机会使用它访问无效数据，因此编译器允许这种赋值。
编译器是如何区分两种情况的呢？答案是判断右值：
unique_ptr<string> p1(new string("example"));
unique_ptr<string> p2;
p2 = p1; // not allow
p2 = unique_ptr<string>(new string("example")); // allow
也就是说，如果源 unique_ptr 是一个临时右值，编译器允许赋值，反之不行。因此 unique_ptr 优于 auto_ptr ，因为后者将允许这两种赋值。如果一定要使用第一种方式赋值，可以采用 std::move() ，该函数类似于 demo ，将返回一个 unique_ptr 对象：
unique_ptr<string> p1(new string("example"));
unique_ptr<string> p2;
p2 = std::move(p1); // allow
unique_ptr 优于 auto_ptr 的另一个原因是 unique_ptr 可以用于数组，而 auto_ptr 不能。因此 unique_ptr 可与 new [] 配套使用，而 auto_ptr 只能与 new 配套使用。
根据不同智能指针的特点，若有多个智能指针同时指向同一个对象，则使用 shared_ptr ，否则建议使用 unique_ptr 。
二、泛型编程
STL 是一种泛型编程，面向对象编程关注的是编程的数据方面，而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码，但理念决然不同。泛型编程旨在编写独立于数据类型的代码。
1. 迭代器
顾名思义，迭代器就是用于迭代获取 STL 中不同容器的方式：
// 数组迭代访问，相应元素的引用就是迭代器
for(int i = 0; i < n; ++i)
return &arr[i];
// 链表迭代访问，start实际上就是迭代器
for(start = head; start != nullptr; start = start->next)
return start;
从细节上看，二者的实现存在差异；但从功能上看，二者是相同的。因此泛型编程注重的就是算法的功能，而不关注具体实现，对于相同的功能，要求给出一个相同的函数接口和相同的使用方法，因此迭代器需要具备以下特征：
- 应能够对迭代器执行解除引用的操作，以便能够访问它引用的值。
- 应能够将一个迭代器赋给另一个；
- 应能够将一个迭代器与另一个进行比较，判断是否相等；
- 应能够使用迭代器遍历容器中的所有元素；
这样对于查找函数来说，可以如下编写：
typedef double * iterator；
iterator find_arr(iterator ar, int n, const double & val) {
for(int i = 0; i < n; ++i, ++ar)
if(*ar == val)
return ar;
return nullptr;
}
还可以使用两个指针标记容器的起始与结束：
typedef double * iterator；
iterator find_arr(iterator begin, iterator end, const double & val) {
iterator ar;
for(ar = begin; ar != end; ++ar)
if(*ar == val)
return ar;
return nullptr;
}
此处只给出了指针的迭代器版本，对于不同的容器，所使用的迭代器不一定是指针，也可能是对象，但必须要满足泛型编程的准则。
2. 迭代器类型
不同算法对迭代器要求不同，例如查找算法需要定义 ++ 运算符，以便能够遍历整个容器，但它要求只能读取数据而不能修改。而排序算法要求能随机访问，以便能交换两个不相邻的元素。STL 定义了 5 种迭代器：
- 输入迭代器：针对程序的角度，从容其中获取数据称为输入，因此输入迭代器可被程序用来读取容器中的信息，支持 ++ 运算符。但是对于两次迭代器遍历，它们的顺序可能会发生改变；输入迭代器被递增后，也不能保证其先前的值仍然可以被解除引用。该算法应当是单同行的，不依赖于前一次遍历时的迭代器值，也不依赖于本次遍历中前面的迭代器值。
- 输出迭代器：用于将信息从程序传输给容器的迭代器，允许引用让程序能够修改容器值，而不能读取。也就是说，对于单同行只读算法，可以使用输入迭代器；对于单同行只写算法，可以使用输出迭代器。
- 正向迭代器：与前两种相似，只能使用 ++ 运算符来遍历容器，但是它总是按照相同的顺序遍历值。另外，将正向迭代器递增后，仍然可以对前面的迭代器值解除引用，并可以得到相同的值。正向迭代器既可以读取数据，也可以修改数据：
int * p; // 可读写 const int * p; // 只读 - 双向迭代器：支持递增、递减两种运算符。
- 随机访问迭代器：
表达式 描述 a + n 指向 a 所指向的元素后的第 n 个元素 n + a 与 a + n 相同 a - n 指向 a 所指向的元素前的第 n 个元素 r += n 等价于 r = r + n r -= n 等价于 r = r - n a[n] 等价于 *(a + n) b - a 结果为这样的 n 值，即 b = a + n a < b 如果 b - a > 0 ，则为真 a > b 如果 b < a ，则为真 a >= b 如果 !(a < b) ，则为真 a <= b 如果 !(a > b) ，则为真
三、函数对象
很多 STL 算法都使用函数对象——也叫函数符（functor），它是可以以函数方式与 () 结合使用的任意对象。这包括函数名、指向函数的指针和重载了 () 运算符的类对象：
class Linear {
private:
double slope;
double y0;
public:
Linear(double sl_ = 1, double y_ = 0) : slope(sl_), y0(y_) {}
double operator()(double x) {return y0 + slope * x;} // 重载()
};
Linear f1;
Linear f2(2.5, 10.0);
double y1 = f1(12.5);
double y2 = f2(0.4);
这样重载 () 运算符将使得能够像函数那样使用 Linear 对象。对于下面这个函数存在一个问题，如何定义第三个参数？
for_each(books.begin(), books.end(); showReview); // 对books容器中每个元素使用showReview函数处理
首先考虑使用函数指针，但是函数指针需要制定参数类型，因此不可用。然后考虑模板：
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f); // 一元函数
void ShowReview(const Review &); // ShowReview原型
此时，便完成了对第三个参数的定义。由上面的例子便可得到函数符的概念：
- 生成器（generator）是不用参数就可以调用的函数符；
- 一元函数（unary function）是用一个参数可以调用的函数符；
- 二元函数（binary function）是用两个参数可以调用的函数符；
- 返回 bool 值的一元函数是谓词（predicate）；
- 返回 bool 值的二元函数是二元谓词（binary predicate）。