STL标准模板库 知识点总结

 1 template<class T, class Alloc = alloc, size_t BufSiz = 0>  
 2 class deque{  
 3 public :  
 4     typedef T value_type ;  
 5     typedef value_type* pointer ;  
 6     ...  
 7 protected :  
 8     //元素的指针的指针(pointer of pointer of T)  
 9     // 其实就是T**，一个二级指针，维护一个二维数组
10     typedef pointer* map_pointer ; 
11   
12 protected :  
13     map_pointer map ; //指向map,map是块连续空间，其内的每个元素  
14                       //都是一个指针(称为节点)，指向一块缓冲区  
15     size_type map_size ;//map内可容纳多少指针  
16     ...  
17 };  

 1 template<tyepname T,...>
 2 struct __list_iterator{
 3     __list_node<T>* node;
 4     //...
 5     //重载 == 运算符
 6     bool operator==(const __list_iterator& x){return node == x.node;}
 7     //重载 != 运算符
 8     bool operator!=(const __list_iterator& x){return node != x.node;}
 9     //重载 * 运算符，返回引用类型
10     T* operator *() const {return *(node).myval;}
11     //重载前置 ++ 运算符
12     __list_iterator<T>& operator ++(){
13         node = (*node).next;
14         return *this;
15     }
16     //重载后置 ++ 运算符
17     __list_iterator<T>& operator ++(int){
18         __list_iterator<T> tmp = *this;
19         ++(*this);
20         return tmp;
21     }
22     //重载前置 -- 运算符
23     __list_iterator<T>& operator--(){
24         node = (*node).prev;
25         return *this;
26     }
27     //重载后置 -- 运算符
28     __list_iterator<T> operator--(int){
29         __list_iterator<T> tmp = *this;
30         --(*this);
31         return tmp;
32     }
33     //...
34 }

 1 //deque<T> >中间有个空格是为了兼容较老的版本
 2 template <class T, class Sequence = deque<T> >
 3 class stack {
 4     // 以下的 __STL_NULL_TMPL_ARGS 会开展为 <>
 5     friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);
 6     friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);
 7 public:
 8     typedef typename Sequence::value_type value_type;
 9     typedef typename Sequence::size_type size_type;
10     typedef typename Sequence::reference reference;
11     typedef typename Sequence::const_reference const_reference;
12 protected:
13     Sequence c; // 底层容器
14 public:
15     // 以下完全利用 Sequence c 的操作，完成 stack 的操作。
16     bool empty() const { return c.empty(); }
17     size_type size() const { return c.size(); }
18     reference top() { return c.back(); }
19     const_reference top() const { return c.back(); }
20     // deque 是两头可进出，stack 是末端进，末端出（所以后进者先出）。
21     void push(const value_type& x) { c.push_back(x); }
22     void pop() { c.pop_back(); }
23 };
24 
25 template <class T, class Sequence>
26 bool operator==(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {
27     return x.c == y.c;
28 }
29 
30 template <class T, class Sequence>
31 bool operator<(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {
32     return x.c < y.c;
33 }

 1 #include<stack>  
 2   #include<list>  
 3   #include<algorithm>  
 4   #include <iostream>  
 5   using namespace std;  
 6     
 7   int main(){  
 8       stack<int, list<int>> istack;  
 9       istack.push(1);  
10       istack.push(3);  
11       istack.push(5);  
12         
13       cout << istack.size() << endl; //3  
14       cout << istack.top() << endl;//5  
15       istack.pop();  
16       cout << istack.top() << endl;//3  
17       cout << istack.size() << endl;//2  
18     
19       system("pause");  
20       return 0;  
21   }  

 1 template <class T, class Sequence = deque<T> >
 2 class queue {
 3   friend bool operator== __STL_NULL_TMPL_ARGS (const queue& x, const queue& y);
 4   friend bool operator< __STL_NULL_TMPL_ARGS (const queue& x, const queue& y);
 5 public:
 6   typedef typename Sequence::value_type value_type;
 7   typedef typename Sequence::size_type size_type;
 8   typedef typename Sequence::reference reference;
 9   typedef typename Sequence::const_reference const_reference;
10 protected:
11   Sequence c;
12 public:
13   bool empty() const { return c.empty(); }
14   size_type size() const { return c.size(); }
15   reference front() { return c.front(); }
16   const_reference front() const { return c.front(); }
17   reference back() { return c.back(); }
18   const_reference back() const { return c.back(); }
19   void push(const value_type& x) { c.push_back(x); }
20   void pop() { c.pop_front(); }
21 };
22 
23 template <class T, class Sequence>
24 bool operator==(const queue<T, Sequence>& x, const queue<T, Sequence>& y) {
25   return x.c == y.c;
26 }
27 
28 template <class T, class Sequence>
29 bool operator<(const queue<T, Sequence>& x, const queue<T, Sequence>& y) {
30   return x.c < y.c;
31 }

1 template<class _Kty,
2     class _Pr = less<_Kty>,
3     class _Alloc = allocator<_Kty> >
4 class set

1 template<class _Kty,
2     class _Pr = less<_Kty>,
3     class _Alloc = allocator<_Kty> >
4 class multiset

1 find(beg, end, val); // 返回一个迭代器，指向输入序列中第一个等于 val 的元素，未找到返回 end
2 find_if(beg, end, unaryPred); // 返回一个迭代器，指向第一个满足 unaryPred 的元素，未找到返回 end
3 find_if_not(beg, end, unaryPred); // 返回一个迭代器，指向第一个令 unaryPred 为 false 的元素，未找到返回 end
4 count(beg, end, val); // 返回一个计数器，指出 val 出现了多少次
5 count_if(beg, end, unaryPred); // 统计有多少个元素满足 unaryPred
6 all_of(beg, end, unaryPred); // 返回一个 bool 值，判断是否所有元素都满足 unaryPred
7 any_of(beg, end, unaryPred); // 返回一个 bool 值，判断是否任意（存在）一个元素满足 unaryPred
8 none_of(beg, end, unaryPred); // 返回一个 bool 值，判断是否所有元素都不满足 unaryPred

1 adjacent_find(beg, end); // 返回指向第一对相邻重复元素的迭代器，无相邻元素则返回 end
2 adjacent_find(beg, end, binaryPred); // 返回指向第一对相邻重复元素的迭代器，无相邻元素则返回 end
3 search_n(beg, end, count, val); // 返回一个迭代器，从此位置开始有 count 个相等元素，不存在则返回 end
4 search_n(beg, end, count, val, binaryPred); // 返回一个迭代器，从此位置开始有 count 个相等元素，不存在则返回 end

1 search(beg1, end1, beg2, end2); // 返回第二个输入范围（子序列）在爹一个输入范围中第一次出现的位置，未找到则返回 end1
2 search(beg1, end1, beg2, end2, binaryPred); // 返回第二个输入范围（子序列）在爹一个输入范围中第一次出现的位置，未找到则返回 end1
3 find_first_of(beg1, end1, beg2, end2); // 返回一个迭代器，指向第二个输入范围中任意元素在第一个范围中首次出现的位置，未找到则返回end1
4 find_first_of(beg1, end1, beg2, end2, binaryPred); // 返回一个迭代器，指向第二个输入范围中任意元素在第一个范围中首次出现的位置，未找到则返回end1
5 find_end(beg1, end1, beg2, end2); // 类似 search，但返回的最后一次出现的位置。如果第二个输入范围为空，或者在第一个输入范围为空，或者在第一个输入范围中未找到它，则返回 end1
6 find_end(beg1, end1, beg2, end2, binaryPred); // 类似 search，但返回的最后一次出现的位置。如果第二个输入范围为空，或者在第一个输入范围为空，或者在第一个输入范围中未找到它，则返回 end1

1 for_each(beg, end, unaryOp); // 对输入序列中的每个元素应用可调用对象 unaryOp，unaryOp 的返回值被忽略
2 mismatch(beg1, end1, beg2); // 比较两个序列中的元素。返回一个迭代器的 pair，表示两个序列中第一个不匹配的元素
3 mismatch(beg1, end1, beg2, binaryPred); // 比较两个序列中的元素。返回一个迭代器的 pair，表示两个序列中第一个不匹配的元素
4 equal(beg1, end1, beg2); // 比较每个元素，确定两个序列是否相等。
5 equal(beg1, end1, beg2, binaryPred); // 比较每个元素，确定两个序列是否相等。

1 lower_bound(beg, end, val); // 返回一个非递减序列 [beg, end) 中的第一个大于等于值 val 的位置的迭代器，不存在则返回 end
2 lower_bound(beg, end, val, greater<type>()); // 返回一个非递减序列 [beg, end) 中的第一个小于等于值 val 的位置的迭代器，不存在则返回 end
3 upper_bound(beg, end, val); // 返回一个非递减序列 [beg, end) 中第一个大于 val 的位置的迭代器，不存在则返回 end
4 upper_bound(beg, end, val, greater<type>()); // 返回一个非递减序列 [beg, end) 中第一个小于等于 val 的位置的迭代器，不存在则返回 end
5 equal_range(beg, end, val); // 返回一个 pair，其 first 成员是 lower_bound 返回的迭代器，其 second 成员是 upper_bound 返回的迭代器
6 binary_search(beg, end, val); // 返回一个 bool 值，指出序列中是否包含等于 val 的元素。对于两个值 x 和 y，当 x 不小于 y 且 y 也不小于 x 时，认为它们相等。

1 fill(beg, end, val); // 将 val 赋予每个元素，返回 void
2 fill_n(beg, cnt, val); // 将 val 赋予 cnt 个元素，返回指向写入到输出序列最有一个元素之后位置的迭代器
3 genetate(beg, end, Gen); // 每次调用 Gen() 生成不同的值赋予每个序列，返回 void
4 genetate_n(beg, cnt, Gen); // 每次调用 Gen() 生成不同的值赋予 cnt 个序列，返回指向写入到输出序列最有一个元素之后位置的迭代器

 1 copy(beg, end, dest); // 从输入范围将元素拷贝所有元素到 dest 指定定的目的序列
 2 copy_if(beg, end, dest, unaryPred); // 从输入范围将元素拷贝满足 unaryPred 的元素到 dest 指定定的目的序列
 3 copy_n(beg, n, dest); // 从输入范围将元素拷贝前 n 个元素到 dest 指定定的目的序列
 4 move(beg, end, dest); // 对输入序列中的每个元素调用 std::move，将其移动到迭代器 dest 开始始的序列中
 5 transform(beg, end, dest, unaryOp); // 调用给定操作（一元操作），并将结果写到dest中
 6 transform(beg, end, beg2, dest, binaryOp); // 调用给定操作（二元操作），并将结果写到dest中
 7 replace_copy(beg, end, dest, old_val, new_val); // 将每个元素拷贝到 dest，将等于 old_val 的的元素替换为 new_val
 8 replace_copy_if(beg, end, dest, unaryPred, new_val); // 将每个元素拷贝到 dest，将满足 unaryPred 的的元素替换为 new_val
 9 merge(beg1, end1, beg2, end2, dest); // 两个输入序列必须都是有序的，用小于号运算符将合并后的序列写入到 dest 中
10 merge(beg1, end1, beg2, end2, dest, comp); // 两个输入序列必须都是有序的，使用给定的比较操作（comp）将合并后的序列写入到 dest 中

1 is_partitioned(beg, end, unaryPred); // 如果所有满足谓词 unaryPred 的元素都在不满足 unarypred 的元素之前，则返回 true。若序列为空，也返回 true
2 partition_copy(beg, end, dest1, dest2, unaryPred); // 将满足 unaryPred 的元素拷贝到到 dest1，并将不满足 unaryPred 的元素拷贝到到 dest2。返回一个迭代器 pair，其 first 成员表示拷贝到 dest1 的的元素的末尾，second 表示拷贝到 dest2 的元素的末尾。
3 partitioned_point(beg, end, unaryPred); // 输入序列必须是已经用 unaryPred 划分过的。返回满足  unaryPred 的范围的尾后迭代器。如果返回的迭代器不是 end，则它指向的元素及其后的元素必须都不满足 unaryPred
4 stable_partition(beg, end, unaryPred); // 使用 unaryPred 划分输入序列。满足 unaryPred 的元素放置在序列开始，不满足的元素放在序列尾部。返回一个迭代器，指向最后一个满足 unaryPred 的元素之后的位置如果所有元素都不满足 unaryPred，则返回 beg
5 partition(beg, end, unaryPred); // 使用 unaryPred 划分输入序列。满足 unaryPred 的元素放置在序列开始，不满足的元素放在序列尾部。返回一个迭代器，指向最后一个满足 unaryPred 的元素之后的位置如果所有元素都不满足 unaryPred，则返回 beg

 1 sort(beg, end); // 排序整个范围
 2 stable_sort(beg, end); // 排序整个范围（稳定排序）
 3 sort(beg, end, comp); // 排序整个范围
 4 stable_sort(beg, end, comp); // 排序整个范围（稳定排序）
 5 is_sorted(beg, end); // 返回一个 bool 值，指出整个输入序列是否有序
 6 is_sorted(beg, end, comp); // 返回一个 bool 值，指出整个输入序列是否有序
 7 is_sorted_until(beg, end); // 在输入序列中査找最长初始有序子序列，并返回子序列的尾后迭代器
 8 is_sorted_until(beg, end, comp); // 在输入序列中査找最长初始有序子序列，并返回子序列的尾后迭代器
 9 partial_sort(beg, mid, end); // 排序 mid-beg 个元素。即，如果 mid-beg 等于 42，则此函数将值最小的 42 个元素有序放在序列前 42 个位置
10 partial_sort(beg, mid, end, comp); // 排序 mid-beg 个元素。即，如果 mid-beg 等于 42，则此函数将值最小的 42 个元素有序放在序列前 42 个位置
11 partial_sort_copy(beg, end, destBeg, destEnd); // 排序输入范围中的元素，并将足够多的已排序元素放到 destBeg 和 destEnd 所指示的序列中
12 partial_sort_copy(beg, end, destBeg, destEnd, comp); // 排序输入范围中的元素，并将足够多的已排序元素放到 destBeg 和 destEnd 所指示的序列中
13 nth_element(beg, nth, end); // nth 是一个迭代器，指向输入序列中第 n 大的元素。nth 之前的元素都小于等于它，而之后的元素都大于等于它
14 nth_element(beg, nth, end, comp); // nth 是一个迭代器，指向输入序列中第 n 大的元素。nth 之前的元素都小于等于它，而之后的元素都大于等于它

 1 remove(beg, end, val); // 通过用保留的元素覆盖要删除的元素实现删除 ==val 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
 2 remove_if(beg, end, unaryPred); // 通过用保留的元素覆盖要删除的元素实现删除满足 unaryPred 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
 3 remove_copy(beg, end, dest, val); // 通过用保留的元素覆盖要删除的元素实现删除 ==val 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
 4 remove_copy_if(beg, end, dest, unaryPred); // 通过用保留的元素覆盖要删除的元素实现删除满足 unaryPred 的元素，返回一个指向最后一个删除元素的尾后位置的迭代器
 5 unique(beg, end); // 通过对覆盖相邻的重复元素（用 == 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
 6 unique (beg, end, binaryPred); // 通过对覆盖相邻的重复元素（用 binaryPred 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
 7 unique_copy(beg, end, dest); // 通过对覆盖相邻的重复元素（用 == 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
 8 unique_copy_if(beg, end, dest, binaryPred); // 通过对覆盖相邻的重复元素（用 binaryPred 确定是否相同）实现重排序列。返回一个迭代器，指向不重复元素的尾后位置
 9 rotate(beg, mid, end); // 围绕 mid 指向的元素进行元素转动。元素 mid 成为为首元素，随后是 mid+1 到到 end 之前的元素，再接着是 beg 到 mid 之前的元素。返回一个迭代器，指向原来在 beg 位置的元素
10 rotate_copy(beg, mid, end, dest); // 围绕 mid 指向的元素进行元素转动。元素 mid 成为为首元素，随后是 mid+1 到到 end 之前的元素，再接着是 beg 到 mid 之前的元素。返回一个迭代器，指向原来在 beg 位置的元素

1 reverse(beg, end); // 翻转序列中的元素，返回 void
2 reverse_copy(beg, end, dest);; // 翻转序列中的元素，返回一个迭代器，指向拷贝到目的序列的元素的尾后位置

1 random_shuffle(beg, end); // 混洗输入序列中的元素，返回 void
2 random_shuffle(beg, end, rand); // 混洗输入序列中的元素，rand 接受一个正整数的随机对象，返回 void
3 shuffle(beg, end, Uniform_rand); // 混洗输入序列中的元素，Uniform_rand 必须满足均匀分布随机数生成器的要求，返回 void

 1 min(val1, va12); // 返回 val1 和 val2 中的最小值，两个实参的类型必须完全一致。参数和返回类型都是 const的引引用，意味着对象不会被拷贝。下略
 2 min(val1, val2, comp);
 3 min(init_list);
 4 min(init_list, comp);
 5 max(val1, val2);
 6 max(val1, val2, comp);
 7 max(init_list);
 8 max(init_list, comp);
 9 minmax(val1, val2); // 返回一个 pair，其 first 成员为提供的值中的较小者，second 成员为较大者。下略
10 minmax(vall, val2, comp);
11 minmax(init_list);
12 minmax(init_list, comp);
13 min_element(beg, end); // 返回指向输入序列中最小元素的迭代器
14 min_element(beg, end, comp); // 返回指向输入序列中最小元素的迭代器
15 max_element(beg, end); // 返回指向输入序列中最大元素的迭代器
16 max_element(beg, end, comp); // 返回指向输入序列中最大元素的迭代器
17 minmax_element(beg, end); // 返回一个 pair，其中 first 成员为最小元素，second 成员为最大元素
18 minmax_element(beg, end, comp); // 返回一个 pair，其中 first 成员为最小元素，second 成员为最大元素

1 lexicographical_compare(beg1, end1, beg2, end2);
2 lexicographical_compare(beg1, end1, beg2, end2, comp);