《C++ Primer Plus》16.4 泛型编程学习笔记

STL是一种泛型编程（generic programming）。面向对象编程关注的是编成的数据方面，而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码，单他们的理念决然不同。
泛型编程旨在编写独立于数据类型的代码。

16.4.1 为何使用迭代器
理解迭代器是理解STL的关键所在。模板使得算法独立于存储的数据类型，而迭代其使算法独立于使用的容器类型。因此，它们都是STL通用方法的重要组成部分。
为了解为何需要迭代器，我们来看如何为两种不同数据表现实现find函数，然后来看如何推广这种方法。首先来看一个在double数组中搜索特定值的函数，可以这样编写该函数：
double * find_ar(double * ar, int n, const double & val)
{
    for (int i = 0; i < n; i ++)
        if (ar[i] == val)
            return &ar[i];
    return 0;   // or, in C++11, return nullptr;
}
如果函数在数组中找到这样的值，则返回该值在数组中的地址，否则返回一个空指针。该函数使用下标来便利数组。可以用模板将这种算法推广到包含==运算符的、任意类型的数组。尽管这样，这种算法仍然与一种特定的数据结构（数组）关联在一起。
下面来看搜索另一种数据结构——链表的情况（第12章使用链表实现了Queue类）。链表由连接在一起的Node结构组成：
struct Node
{
    double item;
    Node * p_next;
};
假设有一个指向链表第一个节点的指针，每个节点的p_next指针都指向下一个节点，链表最后一个节点的p_next指针被设置为0，则可以这样编写find_ll()函数：
Node* find_ll(Node * head, const double & val)
{
    Node * start;
    for (start = head; start != 0; start = start->p_next)
        if (start->item == val)
            return start;
    return 0;
}
同样，也可以使用模板将这种算法推官到支持==运算符的任何数据类型的链表。然而，这种算法也是与特定的数据结构——链表关联在一起。
从实现细节上看，这两个find函数的算法是不同的：一个使用数组索引来便利元素，另一个则将start重置为start->p_next。但从冠以上说，这两种算法是相同的：将值依次与容器中的每一个值进行比较，知道找到匹配的位置。
泛型编程旨在使用同一个find函数来处理数组、链表或任何其他容器类型。即函数不仅独立于容器中存储的数据类型，而且独立于容器本身的数据结构。模板提供了存储在容器中的数据类型的通用表示，因此还需要便利容器中的值的通用表示，迭代器正式这样的通用表示。
要实现find函数，迭代器应具备的特征：
* 应能够对迭代其执行解除引用的操作，一边能够访问它引用的值。即如果p是一个迭代其，则应对*p进行定义。
* 应能够将一个迭代其赋给另一个。即如果p和q都是迭代器，则应对表达式p=q进行定义。
* 应能够将一个迭代器与另一个进行比较，看它们是否相等。即如果p和q都是迭代其，则应对p==q和p!=q进行定义。
* 应能够使用迭代其便利容器中的所有元素，这可以通过为迭代其p定义++p和p++来实现。
常规指针就能满足迭代器的要求，因此，可以这样重新编写find_arr()函数：
typedef double * iterator;
iterator find_ar(iterator ar, int n, const double double & val)
{
    for (int i = 0; i < n; i++, ar++)
        if (*ar == val)
            return ar;
    return 0;
}
然后可以修改函数参数，使之接受两个指示区间的指针参数，其中的一个指向数组的起始位置，另一个指向数组的超尾；同时函数可以通过返回尾指针，来指出没有找到要找的值。下面的find_ar()版本完成了这些修改：
typedef double * iterator;
iterator find_ar(iterator begin, iterator end, const double & val)
{
    iterator ar;
    for (ar = begin; ar != end; ar++)
        if (*ar == vale)
            return ar;
    return end;     // indicates val not found
}
对于find_ll()函数，可以定义一个迭代器类，其中定义了运算符*和++：
struct Node
{
    double item;
    Node * p_next;
};

class iterator
{
    Node * pt;
public:
    iteraotr() :p t(0) {}
    iterator (Node * pn) : pt(n) {}
    double operator*() { return pt->item; }
    iterator& operator++() // for ++it
    {
        pt = pt->next;
        return *this;
    }
    iterator oprator++(int) // for it++
    {
        iterator tmp = *this;
        pt = pt->next;
        return tmp;
    }
// ... oprator==(), operator!=(), etc.
};
为区分++运算符的前缀版本和后缀版本，C++将operator++作为前缀版本，将operator++(int)作为后缀版本：其中的参数永远也不会被用到，所以不比指定其名称。
这里重点不是如何定义iterator类，而是有了这样的类后，第二个find函数就可以这样编写了：
iterator find_ll(iterator head, const double & val)
{
    iterator start;
    for (start = head; start != 0; ++ start)
        if (*start == val)
            return start;
    return 0;
}
STL遵循上面介绍的方法。首先，每个容器类（vector、list、deque等）定义了相应的迭代其类型。对于其中的某个类，迭代其可能是指针；而对于另一个类，则肯呢哥是对象。不管实现方式如何，迭代其都将提供所需的操作，如*和++（有些累需要的操作可能比其他类多）。其次，每个容器类都有一个超微标记，当迭代其递增到超越容器的最后一个值后，这个值将被賦给迭代其。每个容器类都有begin()和end()方法，他们呢分别返回一个指向容器的第一个元素和超尾位置的迭代其。每个容器类都使用++操作，让迭代其从指向第一个元素逐步指向超微位置，从而便利容器中的每一个元素。
STL通过为每个类定义适当的迭代其，并以统一的风格射击类，能够对内部表示决然不同的容器，编写相同的代码。
使用C++11新增的自动类型推断可进一步简化：对于矢量或列表，都可使用如下代码：
for (auto pr = scores.begin(); pr != scores.end(); pr ++)
    cout << *pr << endl;
z实际上，作为一种变成风个，最好避免直接使用迭代其，而应尽可能使用STL函数（如for_each()）来处理细节。也可以使用C++11新增的基于范围的for循环：
for (auto x : scores) cout << x << endl;
总结一下STL方法：首先是处理容器的方法，应尽可能用通用的属于来表达算法，使之独立于数据类型和容器类性。为使通用算法能够适用于具体情况，应定义能够满足算法需求的迭代其，并把要求加到容器设计上。即基于算法的要求，设计基本迭代其的特征和容器特征。

16.4.2 迭代器类型
STL定义了五种类型的迭代器：输入迭代器、输出迭代器、正向迭代器、双向迭代器、随机迭代器。

16.4.3 迭代器层次结构
……

16.4.4 概念、改进和模型
……

16.4.5 容器种类
以前的11个容器类型分别是：deque,list,queue,priority_queue,stack,vector,map,multimap,set,multiset,bitset
C++新增了forward_list,unordered_map,unordered_multimap,unordered_set,unordered_multiset，且不将bitset视为容器，而将其视为一种独立的类别。
【这里包含各个种类容器的介绍*】