http://blog.csdn.net/amin2001/article/details/8063
STL容器在被添加时（通过insert、push_front、push_back等）自动扩展它们自己来容纳新对象。这工作的很好，有些程序员因为这个信仰而被麻痹，认为他们不必担心要为容器中的对象腾出空间，因为容器自己可以照顾好这些。如果是那样就好了！当程序员想向容器中插入对象但并没有告诉STL他们所想的时，问题出现了。这是一个常见的可以自我表现的方法：
int transmogrify(int x); // 这个函数从x
// 产生一些新值
vector<int> values;
... // 把数据放入values
vector<int> results; // 把transmogrify应用于
transform(values.begin(), values.end(), // values中的每个对象
results.end(), // 把这个返回的values
transmogrify); // 附加到results
// 这段代码有bug！
在本例中，transform被告知它的目的区间是从results.end()开始的，所以那就是开始写在values的每个元素上调用transmogrify的结果的地方。就像所有使用目标区间的算法，transform通过对目标区间的元素赋值的方法写入结果，transform会把transmogrify应用于values[0]并把结果赋给*results.end()。然后它会把transmogrify应用于value[1]并把结果赋给*(results.end()+1)。那只能带来灾难，因为在*results.end()没有对象，*(results.end()+1)也没有！调用transform是错误的，因为它会给不存在的对象赋值。（条款50解释了STL的一个调试实现怎么在运行期检测这个问题。）犯了这种错误的程序员几乎总是以为他们调用算法的结果能插入目标容器。如果那是你想要发生的，你就必须说出来。STL是一个库，不是一个精神。在本例中，说“请把transform的结果放入叫做results容器的结尾”的方式是调用back_inserter来产生指定目标区间起点的迭代器：
vector<int> results; // 把transmogrify应用于 transform(values.begin(), values.end(), // values中的每个对象， back_inserter(results), // 在results的结尾 transmogrify); // 插入返回的values
在内部，back_inserter返回的迭代器会调用push_back，所以你可以在任何提供push_back的容器上使用back_inserter（也就是任何标准序列容器：vector、string、deque和list）。如果你想让一个算法在容器的前端插入东西，你可以使用front_inserter。在内部，front_inserter利用了push_front，所以front_insert只和提供那个成员函数的容器配合（也就是deque和list）：
... // 同上 list<int> results; // results现在是list transform(values.begin(), values.end(), // 在results前端 front_inserter(results), // 以反序 transmogrify); // 插入transform的结果
因为front_inserter用push_front把每个对象添加到results，results中的对象顺序会和values中对应的对象顺序相反。这也是为什么front_inserter没有back_inserter那么常用的原因之一。另一个原因是vector不提供push_front，所以front_inserter不能用于vector。
如果你要transform把输出结果放在results前端，但你也要输出和values中对应的对象顺序相同，只要以相反的顺序迭代values：
list<int> results; // 同上 transform(values.rbegin(), values.rend(), // 在results前端 front_inserter(results), // 插入transform的结果 transmogrify); // 保持相对的对象顺序
front_inserter让你强制算法在容器前端插入它们的结果，back_inserter让你告诉它们把结果放在容器后端，有点惊人的是inserter允许你强制算法把它们的结果插入容器中的任意位置：
vector<int> values; // 同上
...
vector<int> results; // 同上，除了现在
... // 在调用transform前
// results已经有一些数据
transform(values.begin(), values.end(), // 把transmogrify的
inserter(results, results.begin() + results.size()/2), // 结果插入
transmogrify); // results的中间
不管你是否使用了back_inserter、front_inserter或inserter，每次对目的区间的插入只完成一个对象。条款5解释了对于连续内存容器（vector、string和deque）来说这可能很昂贵，但条款5的建议解决方法（使用区间成员函数）不能应用于使用算法来完成插入的情况。在本例中，transform会对目的区间每次写入一个值，你无法改变。
当你要插入的容器是vector或string时，你可以通过按照条款14的建议最小化这个代价，预先调用reserve。你仍然要承受每次发生插入时移动元素的开销，但至少你避免了重新分配容器的内在内存：
vector<int> values; // 同上
vector<int> results;
...
results.reserve(results.size() + values.size()); // 确定results至少
// 还能装得下
// values.size()个元素
transform(values.begin(), values.end(), // 同上，
inserter(results, results.begin() + results.size() / 2),// 但results
transmogrify); // 没有任何重新分配操作
当使用reserve来提高一连串插入的效率时，总是应该记住reserve只增加容器的容量：容器的大小仍然没有改变。即使调用完reserve，当你想要让容器把新元素加入到vector或string时，你也必须对算法使用插入迭代器（比如，从back_inserter、front_inserter或inserter返回的迭代器之一）。
要把这些完全弄清楚，这里有一个提高本条款开始时的那个例子的效率的错误方法（就是我们把transmogrify作用于values里的数据的结果附加到results的那个例子）：
vector<int> values; // 同上 vector<int> results; ... results.reserve(results.size() + values.size()); // 同上 transform(values.begin(), values.end(), // 写入transmogrify的结果 results.end(), // 到未初始化的内存 transmogrify); // 行为未定义！
在这段代码中，transform愉快地试图对results尾部的原始的、未初始化的内存赋值。通常，这会造成运行期错误，因为赋值只在两个对象之间操作时有意义，而不是在一个对象和一块原始的比特之间。即使这段代码碰巧作了你想要它做的事情，results也不会知道transform在它的未使用容量上“创造”的新“对象”。直到results知道之前，它的大小在调用transform后仍然和原来一样。同样的，它的end迭代器仍和调用transform前指向同样的位置。结论呢？使用reserve而没有用插入迭代器会在算法内部导致未定义行为，也会弄乱容器。
正确地写这个例子的代码的方法是使用reserve和插入迭代器：
vector<int> values; // 同上 vector<int> results; results.reserve(results.size() + values.size()); // 同上 transform(values.begin(), values.end(), // 把transmogrify的结果 back_inserter(results), // 写入results的结尾， transmogrify); // 处理时避免了重新分配
到目前为止，我都在假设你让像transform那样的算法把它们的结果作为新元素插入容器。这是通常的期望，但有时候你要覆盖现有容器的元素而不是插入新的。当这种情况时，你不需要插入迭代器，但你仍然需要按照本条款的建议来确保你的目的区间足够大。
比如，假设你让transform覆盖results的元素。如果results至少有和values一样多的元素，那很简单。如果没有，你也必须使用resize来确保它有。
vector<int> values;
vector<int> results;
...
if (results.size() < values.size()){ // 确保results至少
results.resize(values.size()); // 和values一样大
}
transform(values.begin(), values.end(), // 覆盖values.size()个
results.begin(), // results的元素
transmogrify);
或者你可以清空results然后用通常的方式使用插入迭代器：
...
results.clear(); // 销毁results中
// 的所有元素
results.reserve(values.size()); // 保留足够空间
transform(values.begin(), values.end(), // 把transform地返回值
pack_inserter(results), // 放入results
transmogrify);
本条款论证了这个主题的很多变化，但我希望你能牢牢记住本质。无论何时你使用一个要求指定目的区间的算法，确保目的区间已经足够大或者在算法执行时可以增加大小。如果你选择增加大小，就使用插入迭代器，比如ostream_iterators或从back_inserter、front_inserter或inserter返回的迭代器。这是所有你需要记住的东西。
注意：
copy(ve.begin(),ve.end(),back_inserter(v1));是将ve的数据插入到v1的后面
一：函数模板类
1、一元函数原型
template<class _A,class _R>
struct unary_function
{
typedef _A argument_type;
typedef _R result_type;
};
2、二元函数原型
template<class Arg1,class Arg2,class Result>
struct unary_function
{
typedef Arg1 first_argument_type;
typedef Arg2 Second_argument_type;
typedef Result result_type;
};
3、系统函数对象
plus 返回两个数的和：a+b
minus 返回两个数的差：a-b
multiplies 返回两个数的乘积：a*b
divides 返回两个数的商：a/b
mudulus 返回两个数的模：a%b
negate 返回某个数的相反数：-a
equal_to 判断两个数是否相等：a==b
not_equal_to 判断两个数是否不等：a!=b
greater 判断第一个数是否大于第二个数：a>b
less 判断第一个数是否小于第二个数：a<b
greate_equal 判断第一个数是否大于等于第二个数：a>=b
less_equal 判断第一个数是否小于等于第二个数：a<=b
logical_and 返回两个数的逻辑与结果：a&&b
logical_or 返回两个数的逻辑或结果：a||b
logical_not 返回某个数的逻辑非结果：!a
二：通用容器
1、vector
vector/vector(int nSize) 创建向量容器
assign 对Vector中的元素赋值
at 返回指定位置的元素
back 返回最末一个元素
begin 返回第一个元素的迭代器
capacity 返回vector所能容纳的元素数量(在不重新分配内存的情况下）
clear 清空所有元素
empty 判断Vector是否为空（返回true时为空）
end 返回最末元素的迭代器(译注:实指向最末元素的下一个位置)
erase 删除指定元素
front 返回第一个元素
get_allocator 返回vector的内存分配器
insert 插入元素到Vector中
max_size 返回Vector所能容纳元素的最大数量（上限）
pop_back 移除最后一个元素
push_back 在Vector最后添加一个元素
rbegin 返回Vector尾部的逆迭代器
rend 返回Vector起始的逆迭代器
reserve 设置Vector最小的元素容纳数量
resize 改变Vector元素数量的大小
size 返回Vector元素数量的大小
swap 交换两个Vector
2、list
assign 给list赋值
back 返回最后一个元素
begin 返回指向第一个元素的迭代器
clear 删除所有元素
empty 如果list是空的则返回true
end 返回末尾的迭代器
erase 删除一个元素
front 返回第一个元素
get_allocator 返回list的配置器
insert 插入一个元素到list中
max_size 返回list能容纳的最大元素数量
merge 合并两个list
pop_back 删除最后一个元素
pop_front 删除第一个元素
push_back 在list的末尾添加一个元素
push_front 在list的头部添加一个元素
rbegin 返回指向第一个元素的逆向迭代器
remove 从list删除元素
remove_if 按指定条件删除元素
rend 指向list末尾的逆向迭代器
resize 改变list的大小
reverse 把list的元素倒转
size 返回list中的元素个数
sort 给list排序
splice 合并两个list
swap 交换两个list
unique 删除list中重复的元素
3、deque
push_front 头部添加一个元素
push_back 尾部添加一个元素
insert 插入一个元素
erase 删除一个元素
pop_front 删除最前一个元素
pop_back 删除最后一个元素
clear 清楚所有元素
at 返回指定位置的元素
4、stack
stack<class T,class Container = deque/vector/list<T>> 构造栈
empty 堆栈为空则返回真
pop 移除栈顶元素
push 在栈顶增加元素
size 返回栈中元素数目
top 返回栈顶元素
5、queue
queue<class T,class Container = deque/list<T>> 构造队列
back 返回最后一个元素
empty 如果队列空则返回真
front 返回第一个元素
pop 删除第一个元素
push 在末尾加入一个元素
size 返回队列中元素的个数
6、set
begin 指向set的头指针
clear 删除所有元素
count 返回某键值元素的个数
empty 返回是否为空
end 指向set的尾指针
erase 删除某位置元素
pair<iterator, iterator>equal_range(const key_type& x) 返回一个迭代器对(指向键不小于x的第一个元素的迭代器，指向键大于x的第一个元素的迭代器)
find 返回某索引元素指针
get_allocator 返回构造函数的一个拷贝
pair<iterator,bool>insert(const value_type& x)返回<指向元素x的迭代器，是否插入成功>
lower_bound 返回键值不小于某值的第一个元素的迭代器
max_size 返回该set可以控制的最大长度
rbegin 返回反向set的反向头指针
rend 返回反响set的反向尾指针
resize(size_type Sz, T C=T()) 插入或删除使元素的个数为n，插入的元素为C
7、map
map(const Pred& comp=Pred(),const A& al=A()) 构造函数
pair<const_iterator,const_iterator>equal_range(const Key& key)const: 返回迭代器中键值等于key的迭代指针[fitst,last)
8、迭代器函数
back_inserter 返回容器的后插迭代器
front_inserter 返回容器的前插迭代器
三：非变异算法
1、循环
for_each 对每个元素执行相同的函数操作
2、查询
find 某值第一次出现位置
find_if 符合某谓词的第一个元素
find_first_of 子序列某元素第一次出现位置
adjacent_find 第一次相邻元素相等的位置
find_end 子序列最后出现位置
search 子序列第一次出现位置
search_n 一个值连续出现n次的位置
3、计数
count 某值出现的此时
count_if 与某谓词匹配的次数
4、比较
equal 两个序列对应元素都相同为真
mismatch 两个序列相异的第一个元素
四：变异算法
1、变换
transform 将某操作应用于指定范围的元素
2、填充
fill 用给定值填充所有元素
3、生成
generate 用一操作的结果填充所有元素
4、唯一
unique/unique_copy 删除相邻位置重复的元素
5、反转
reverse/reverse_copy 循环移动元素
6、随机
random_shuffle 随机移动元素
7、划分
partition/stable_paritition 满足谓词的元素都放在前面
五：排序及相关操作
1、排序
sort 以很好的平均效率排序
stable_sort 稳定排序
partial_sort 局部排序
partial_sort_copy 复制时进行局部排序
2、二分检索
lower_bound 大于等于某值第一次出现的迭代器位置
upper_bound 大于某值第一次出现位置
equal_range 等于某值迭代器范围
binary_search 是否存在某值
3、归并
merge 归并两个迭代器有序序列
inplace_merge 归并单个迭代器有序序列
4、有序结构上的集合操作
includes 一个序列为另一个序列子集为真
set_union 构造两集合有序并集
set_intersection 构造有序交集
set_difference 构造有序差集
set_symmetric_difference 构造有序对称差
5、堆操作
make_heap 从序列构造堆
pop_heap 从堆中弹出元素
push_heap 加入元素
sort_heap 排序
6、最大最小
max
min
min_element
max_element
7、词典比较
lexicographical_compare 两个序列按字典序排序
8、排列生成器
next_permutation 按字典序的下一个排序
prev_permutation 按字典序的上一个排序
9、数值算法
accumulate 累积求和
inner_product 内积求和
partial_sum 创建新序列，每个元素值代表指定范围内该位置前所有元素之和
adjacent_difference 相邻元素差集