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）能保证操作的原子性。
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
