The C++ Standard Library 学习笔记（一）第5章

5. 标准模板库

5.1 STL组件

容器，泛型容器，管理对象的集合
迭代器，遍历容器对象的辅助对象，由各个容器提供。
算法，与具体容器分离，运用迭代器操作容器内对象。
STL主张将容器与算法分离，使得算法可以抽象与容器之上，同时操作不同类型的容器，但需要容器提供迭代器。
STL容器只提供效率高的方法，因此不同容器提供的方法可能不一样。
STL是最好的泛型编程的参考资料。

5.2 容器

两种容器
1.       顺序容器（Sequence Containers），元素的位置是确定的，和插入容器的顺序一致。这类容器有：vector, deque, list.
2.       关联容器（Associative Containers），元素是经过排列的，位置和元素的值，排序算法相关，这类容器有：set, multiset, map, multimap.
5.2.1 顺序容器（Sequence Containers）
vector
可以把vector看成是动态数组，在很多实现中，vector的数据部分就是动态数组。它的元素可以随机访问，可以用下标操作符访问。在它的末尾添加和删除元素的速度非常快，而在开始或中间就比较耗时，因为它需要移动元素。适合于访问频繁，而插入、删除操作较少的需求。
 
Deque
deque是双向队列（double-ended queue）的缩写。顾名思义，deque在头和尾插入元素是非常快的，而在中间则较慢。
List
list这里是双向链表，它不能被随机访问，因此它的访问时间是线性的，而它在任何位置插入和删除元素的时间却是常数时间。
5.2.2 关联容器（Associative Containers）
关联容器会自动将它的元素按某个条件（比较各个元素的key的大小）排序。关联容器一般都是以二叉树（binary tree）为基础实现
关联容器有：set，mutiset, map, mutimap.
5.2.3 容器适配器（Container Adapters）
STL提供了下面三种容器适配器：
Stack, Queue, Priority Queue.

5.3迭代器

容器的基本操作，适合于所有容器：
operator*，operator++，operator==，operator!=，and operator=。
容器同时也提供了基本的方法去初始化和遍历容器：
begin(), end()。
容器都有两种迭代器：
container::iterator，和container::const_iterator。
5.3.2 迭代器分类
一般情况下，如果容器可以随机访问，那么它的迭代器也可以随机访问。
迭代器根据其访问规则可分为：
1．  双向迭代器（Bidirectional iterator）
它只能递增或递减来向前或向后访问，这些迭代器的容器有：list，set，mutiset，map，和mutimap。
2．  随机访问迭代器（Random access iterator）
它除了能像双向迭代器一样前后访问外，它还能通过算数运算随机访问元素，并且能使用比较操作符如< 和>，这些迭代器的容器有：vector，deque，以及string。

5.4 算法

算法是STL中的全局函数，它可以通过迭代器操作STL的不同容器，甚至用户自定义的容器。
5.4.1 范围
算法所操作的元素都是以迭代器所表示的一个范围，它使得算法的运用更加灵活，但同时带来了危险：越界，这个需要程序员去保证。
算法所接受的范围都是一个迭代器指定的半开半闭的区间，即：[begin，end）

5.5 迭代器适配器

5.5.1 输入迭代器（Insert Iterator）
输入迭代器常用于算法的输出参数，它使得算法输出到一个能自动扩展空间的容器中，插入这个容器的位置由该迭代器指定。
1.       Back Inserter
back_inserter调用容器的push_back方法，将元素追加到容器中，因此它只能适用于支持push_back方法的容器，如：vector。
2.       Front Inserter
同样，front_inserter调用容器的push_front方法，将元素添加到容器开始，只适用于支持push_front方法的容器，如：deque，list。
3.       Inserter
inserter将元素插入到，第二个参数指定的元素之前。只有他是可以用于关联容器的。
5.5.2 流迭代器（Stream Iterator）
流迭代器是一种从流（标准输入/输出，文件流等）中读取元素，或向流中写入元素。
5.5.3 反向迭代器（Reverse Iterator）
顾名思义，它逆向访问元素。所有的容器可以用rbegin()，和rend()来创建反向迭代器。
5.5.4 迭代器的例子
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <algorithm>
 
using namespace std;
 
int main(int argc, char* argv)
{
    const int N = 10;
 
    //prepare elements
    vector<int> ivec;
    ivec.reserve(N);
    for (int i = 0; i < N; ++i)
    {
        ivec.push_back(i);
    }
 
    //inserter iterator
    list<int> il;
    copy(ivec.begin(), ivec.end(), back_inserter(il));
 
    deque<int> id;
    copy(il.begin(), il.end(), front_inserter(id));
 
    set<int> is;
    copy(id.begin(), id.end(), inserter(is, is.begin()));
 
    //stream iterator
    //output will be: 0 1 2 3 4 5 6 7 8 9
    copy(is.begin(), is.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
 
    //reverse iterator
    //output will be: 9 8 7 6 5 4 3 2 1 0
    copy(il.rbegin(), il.rend(), ostream_iterator<int>(cout, " "));
    cout << endl;
 
    getchar();
    return 0;
};
 
输出：
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0

5.6 操作算法

5.6.1 删除元素
算法remove实际并不删除元素，而是将等于删除值的 位置用后面的元素覆盖掉，然后返回剩余元素的最后一个位置的迭代器。真正要删除元素，则要调用容器（顺序容器）的erase方法
例子：
#include <algorithm>
#include <list>
#include <iostream>
 
template<class Container>
void print(const Container& c, const char* promption)
{
    cout << promption << endl;
    copy(c.begin(), c.end(), ostream_iterator<Container::value_type>(cout, " "));
    cout << endl;
}
 
using namespace std;
int main()
{
    list<int> il;
    //prepare elements
    for (int i = 0; i < 6; ++i)
    {
        il.push_back(i);
        il.push_front(i);
    }
    //print the original elements
    print(il, "original elements:");
 
    //call remove
    list<int>::iterator end = remove(il.begin(), il.end(), 3);
    //print the elements after remove
    print(il, "after remove:");
 
    //print number of elements
    cout << "Number of removed elements: " << distance(end, il.end()) << endl;
    //remove the removed elements
    il.erase(end, il.end());
    //print the elements after real remove
    print(il, "after erase:");
 
    //for 5.6.3
    //call member function to get better performance
    il.remove(4);
    //print the elements after remove 4
    print(il, "removed 4:");
 
    getchar();
    return 0;
}
输出：
original elements:
5 4 3 2 1 0 0 1 2 3 4 5
after remove:
5 4 2 1 0 0 1 2 4 5 4 5
Number of removed elements: 2
after erase:
5 4 2 1 0 0 1 2 4 5
removed 4:
5 2 1 0 0 1 2 5
5.6.2 操作算法和关联容器
注意不能将关联容器作为算法操作的目标容器，因为关联容器的元素的位置是自动排序后的树形结构，操作算法会破坏它的结构。
而关联容器提供了成员函数做诸如remove之类的操作。
5.6.3 成员函数vs 算法
结论：成员函数优先于算法的调用。

5.8 算法的函数参数

5.8.2 Predicates
Predicates即是返回bool值的函数参数，它可能是二元的，也可能是一元的，他们通常是排序或搜索的条件。STL对predicates有特定的要求，对同一个值predicate必须返回同样的结果。

5.9 函数对象（Function Object）

函数对象又称为仿函数（Functor），它也可以作为算法的函数参数。
5.9.1 什么是函数对象
函数对象是行为像函数的对象，因此它必须可以想调用函数那样调用它，也因此它必须重载括号（（））操作符。
函数对象的定义格式：
class Functor
{
public:
    //overload operator ()
    return_type operator()(arguments) const
    {
        ...
    }
};
为什么要使用函数对象，他的优势在哪里呢
1.       函数对象是智能函数
因为它是一个对象，因此它可以有成员函数，和成员变量，同时可以被实例化以应对不同的需求。
2.       每个函数对象有它自己的类型
普通的函数如果是不同的类型，那么只能它的函数原型不同，而函数对象可以通过传递不同的模板参数来生成不同的类型，尽管它们的原型都相同。
3.       通常情况下，函数对象的效率更高
模板在编译时定义了更多的细节，相对于普通函数更容易实现为内联函数。
例子：
#include <algorithm>
#include <iostream>
#include <vector>
#include <cstdlib>
 
using namespace std;
 
bool is_prime(int number)
{
    //ignore the sign
    number = abs(number);
    //0 and 1 are prime numbers
    if (0 == number || 1 == number)
        return true;
 
    //find divisor that divides without a reminder
    int divisor;
    for (divisor = number / 2; 0 != number % divisor; --divisor)
    {
        //nothing
    }
 
    return (1 == divisor);
}
 
template<class InputIterator, class OutputIterator, class Predicate>
void copy_if(InputIterator first, InputIterator last, OutputIterator begin, Predicate p)
{
    while(first != last)
    {
        if (p(*first))
            *(begin++) = *first;
        ++first;
    }
}
 
template<class T>
class Greater
{
public:
    Greater(T value_)
        :_value(value_)
    {
        //empty
    }
 
    bool operator()(T in_) const
    {
        return (in_ > _value);
    }
 
private:
    T _value;
};
 
int main()
{
    //prepare the elements
    vector<int> ivec;
    for (int i = 0; i <= 30; ++i)
    {
        ivec.push_back(i);
    }
 
    //search for prime elements
    vector<int> primes;
    copy_if(ivec.begin(), ivec.end(), back_inserter(primes), is_prime);
 
    cout << "Primes:" << endl;
    copy(primes.begin(), primes.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
 
    //output the primes bigger than 5
    cout << "Primes bigger than 5:" << endl;
    copy_if(primes.begin(), primes.end(), ostream_iterator<int>(cout, " "), Greater<int>(5));
    cout << endl;
 
    getchar();
    return 0;
}
输出：
Primes:
0 1 2 3 5 7 11 13 17 19 23 29
Primes bigger than 5:
7 11 13 17 19 23 29
5.9.2 预定义函数对象
STL提供了许多预定义的函数对象支持基本的操作，例如：set<int>的确实比较函数less<int>， 以及前面例子中的Greater，也有对应的greater<T>，还有作为取反操作的negate<T>，乘法运算的mutiplies<T>
例子：
#include <iostream>
#include <set>
#include <deque>
#include <algorithm>
 
using namespace std;
 
template<class Container>
void print(const Container& c, const char* promption)
{
    cout << promption << endl;
    copy(c.begin(), c.end(), ostream_iterator<Container::value_type>(cout, " "));
    cout << endl;
}
 
int main()
{
    set<int, greater<int> > iset;
    deque<int> ide;
 
    //prepare elements
    for (int i = 1; i < 10; ++i)
    {
        iset.insert(i);
    }
    print(iset, "orignal set:");
 
    //transform all elements to ide by multiplying 10
    transform(iset.begin(), iset.end(),
        back_inserter(ide), bind2nd(multiplies<int>(), 10));
 
    print(ide, "transformed:");
    //replace the value 30 to 200
    replace_if(ide.begin(), ide.end(),
        bind2nd(equal_to<int>(), 30), 200);
    print(ide, "replaced:");
 
    getchar();
    return 0;
}
输出：
orignal set:
9 8 7 6 5 4 3 2 1
transformed:
90 80 70 60 50 40 30 20 10
replaced:
90 80 70 60 50 40 200 20 10

5.10 容器元素

5.10.1 容器元素的要求
容器元素必须满足以下条件：
1.       元素是可拷贝的，容器会在插入元素时创建元素的拷贝，因此元素的拷贝应该是高效的；
2.       元素是可通过复制操作符复制的；
3.       元素是可以被析构的，且析构函数应不抛出异常；
这些条件是所有容器通用的，此外一些特别的容器还有一些特别的需求：
1.       顺序容器的元素必须有缺省构造函数；
2.       很多操作需要 ==  操作符；
3.       对于关联容器，作为排序条件操作必须要有，缺省是 <，由less<> 调用；

5.11 STL中的错误和异常

5.11.1 错误处理
STL的设计目标是更高的效率而不是安全性，因此STL没有引入更多的错误检查，而是由程序员来保证这一点。
5.11.2 异常处理
STL几乎不会因逻辑错误而抛出异常，标准唯一指出一个函数会抛出异常：at()，除此之外，则是标准C++的异常，如bad_alloc。
C++标准库保证：不会在异常发生时泄露资源或违反容器的不变性。
基于节点（node）的容器（如：list，map，set）在很多情况下（除开 remove，remove_if，merge，sort和unique）能保证操作的原子性。