STL2

表（List容器类）：#include <list>
　　 List又叫链表，是一种双线性列表，只能顺序访问（从前向后或者从后向前），图2是list的数据组织形式。与　　前面两种容器类有一个明显的区别就是：它不支持随机访问。要访问表中某个下标处的项需要从表头或表尾处（接近该下标的一端）开始循环。而且缺少下标预算符：operator[]。


图2

　　同时，list仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front()这些基本函数，下面我们来演示一下list的其他函数功能。

merge()：合并两个排序列表；
splice()：拼接两个列表；
sort()：列表的排序；

  1. //stl_cpp_10.cpp
  2. #include <iostream>
  3. #include <string>
  4. #include <list>
  5. using namespace std;
  6. void PrintIt(list<int> n)
  7. {
  8. for(list<int>::iterator iter=n.begin(); iter!=n.end(); ++iter)
  9.    cout<<*iter<<" ";//用迭代器进行输出循环
  10. }
  11. int main(void)
  12. {
  13. list<int> listn1,listn2;
  14. //给listn1,listn2初始化
  15. listn1.push_back(123);
  16. listn1.push_back(0);
  17. listn1.push_back(34);
  18. listn1.push_back(1123);
  19. //now listn1:123,0,34,1123
  20. listn2.push_back(100);
  21. listn2.push_back(12);
  22. //now listn2:12,100
  23. listn1.sort();
  24. listn2.sort();
  25. //给listn1和listn2排序
  26. //now listn1:0,34,123,1123       listn2:12,100
  27. PrintIt(listn1);
  28. cout<<endl;
  29. PrintIt(listn2);
  30. listn1.merge(listn2);
  31. //合并两个排序列表后,listn1:0，12，34，100，123，1123
  32. cout<<endl;
  33. PrintIt(listn1);
  34. cin.get();
  35. }
复制代码

　　上面并没有演示splice()函数的用法，这是一个拗口的函数。用起来有点麻烦。图3所示是splice函数的功能。将一个列表插入到另一个列表当中。list容器类定义了splice()函数的3个版本：

  1. splice(position,list_value);
  2. splice(position,list_value,ptr);
  3. splice(position,list_value,first,last);
复制代码

　　list_value是一个已存在的列表，它将被插入到源列表中，position是一个迭代参数，他当前指向的是要进行拼接的列表中的特定位置。


图3

  1. listn1:123,0,34,1123 listn2:12,100
复制代码

　　执行listn1.splice(find(listn1.begin(),listn1.end(),0),listn2);之后，listn1将变为：123，12，100，34，1123。即把listn2插入到listn1的0这个元素之前。其中，find()函数找到0这个元素在listn1中的位置。值得注意的是，在执行splice之后，list_value将不复存在了。这个例子中是listn2将不再存在。
　　第二个版本当中的ptr是一个迭代器参数，执行的结果是把ptr所指向的值直接插入到position当前指向的位置之前.这将只向源列表中插入一个元素。
　　第三个版本的first和last也是迭代器参数，并不等于list_value.begin(),list_value.end()。First指的是要插入的列的第一个元素，last指的是要插入的列的最后一个元素。

如果listn1:123,0,34,1123 listn2:12,43，87，100 执行完以下函数之后

  1. listn1.splice(find(listn1.begin(),listn1.end(),0),++listn2.begin(),--listn2.end());
  2. listn1:123,43,87,0,34,1123   listn2:12,100
复制代码

　　以上，我们学习了vector,deque,list三种基本顺序容器，其他的顺序容器还有：slist,bit_vector等等。

另一种容器——关联容器（有点费解哦，出去让脑子清醒一下再回来看）
　　与前面讲到的顺序容器相比，关联容器更注重快速和高效地检索数据的能力。这些容器是根据键值（key）来检索数据的，键可以是值也可以是容器中的某一成员。这一类中的成员在初始化后都是按一定顺序排好序的。

集和多集（set 和multiset 容器类）：#include <set>
　　一个集合（set）是一个容器，它其中所包含的元素的值是唯一的。这在收集一个数据的具体值的时候是有用的。集合中的元素按一定的顺序排列，并被作为集合中的实例。如果你需要一个键/值对（pair）来存储数据，map（也是一个关联容器，后面将马上要讲到）是一个更好的选择。一个集合通过一个链表来组织，在插入操作和删除操作上比向量（vector）快，但查找或添加末尾的元素时会有些慢。
　　在集中，所有的成员都是排列好的。如果先后往一个集中插入：12，2，3，123，5，65
　　则输出该集时为：2，3，5，12，65，123
　　集和多集的区别是：set支持唯一键值，set中的值都是特定的，而且只出现一次；而multiset中可以出现副本键，同一值可以出现多次。

Set和multiset的模板参数：

  1. template<class key, class compare, class Allocator=allocator>
复制代码

　　第一个参数key是所存储的键的类型，第二个参数是为排序值而定义的比较函数的类型，第三个参数是被实现的存储分配符的类型。在有些编译器的具体实现中，第三个参数可以省略。第二个参数使用了合适形式的迭代器为键定义了特定的关系操作符，并用来在容器中遍历值时建立顺序。集的迭代器是双向，同时也是常量的，所以迭代器在使用的时候不能修改元素的值。

Set定义了三个构造函数：
默认构造函数：

  1. explicit set(const Compare&=compare());
  2. 如：set<int,less<int> > set1;
复制代码

　　less<int>是一个标准类，用于形成降序排列函数对象。升序排列是用greater<int>。通过指定某一预先定义的区间来初始化set对象的构造函数：

  1. template<class InputIterator> set(InputIterator, InputIterator,\ const Compare&=compare());
  2. 如：set<int ,less<int> >set2(vector1.begin(),vector1.end());
复制代码

复制构造函数：

  2. set（const set<Key,Compare&>）;
  3. 如：set<int ,less<int> >set3(set2);
复制代码

下面我们来看一个简单的集和多集的插入例程：

  1. //stl_cpp_11.cpp
  2. #include <iostream>
  3. #include <set>
  4. using namespace std;
  5. int main(void)
  6. {
  7. set<int> set1;
  8. for(int i=0; i<10; ++i)
  9.     set1.insert(i);
  10. for(set<int>::iterator p=set1.begin();p!=set1.end();++p)
  11.    cout<<*p<<"";
  12.     if(set1.insert(3).second)//把3插入到set1中
  13. //插入成功则set1.insert(3).second返回1，否则返回0
  14. //此例中，集中已经有3这个元素了，所以插入将失败
  15.    cout<<"set insert success";
  16.     else
  17.    cout<<"set insert failed";
  18. int a[] = {4, 1, 1, 1, 1, 1, 0, 5, 1, 0};
  19. multiset<int> A;
  20. A.insert(set1.begin(),set1.end());
  21. A.insert(a,a+10);
  22. cout<<endl;
  23. for(multiset<int>::iterator p=A.begin();p!=A.end();++p)
  24. cout<<*p<<" ";
  25. cin.get();
  26. return 0;
  27. }
复制代码

　　在集之间可以进行并集（set_union()）、交集(set_intersection())、差集(set_diffrence())d等操作，功能强大。

映射和多重映射（map 和multimap）：#include <map>
　　映射和多重映射基于某一类型Key的键集的存在，提供对T类型的数据进行快速和高效的检索。对map而言，键只是指存储在容器中的某一成员。Map不支持副本键，multimap支持副本键。Map和multimap对象包涵了键和各个键有关的值，键和值的数据类型是不相同的，这与set不同。set中的key和value是Key类型的，而map中的key和value是一个pair结构中的两个分量。Map支持下表运算符operator[],用访问普通数组的方式访问map，不过下标为map的键。在multimap中一个键可以对应多个不同的值。

下面的例程说明了map中键与值的关系。

  1. //stl_cpp_12.cpp
  2. #include <iostream>
  3. #include <map>
  4. using namespace std;
  5. int main(void)
  6. {
  7. map<char,int,less<char> > map1;
  8. map<char,int,less<char> >::iterator mapIter;
  9. //char 是键的类型，int是值的类型
  10. //下面是初始化，与数组类似
  11. //也可以用map1.insert(map<char,int,less<char> >::value_type(''c'',3));
  12. map1[''c'']=3;
  13. map1[''d'']=4;
  14. map1[''a'']=1;
  15. map1[''b'']=2;
  16. for(mapIter=map1.begin();mapIter!=map1.end();++mapIter)
  17.    cout<<" "<<(*mapIter).first<<": "<<(*mapIter).second;
  18. //first对应定义中的char键，second对应定义中的int值  
  19. //检索对应于d键的值是这样做的：
  20. map<char,int,less<char> >::const_iterator ptr;
  21. ptr=map1.find(''d'');
  22. cout<<''\n''<<" "<<(*ptr).first<<" 键对应于值："<<(*ptr).second;
  23. cin.get();
  24.    return 0;
  25. }
复制代码

　　从以上例程中，我们可以看到map对象的行为和一般数组的行为类似。Map允许两个或多个值使用比较操作符。下面我们再看看multimap:

  1. //stl_cpp_13.cpp
  2. #include <iostream>
  3. #include <map>
  4. #include <string>
  5. using namespace std;
  6. int main(void)
  7. {
  8. multimap<string,string,less<string> >mulmap;
  9. multimap<string,string,less<string> >::iterator p;
  10. //初始化多重映射mulmap:
  11. typedef multimap<string,string,less<string> >::value_type vt;
  12. typedef string s;
  13. mulmap.insert(vt(s("Tom "),s("is a student")));
  14. mulmap.insert(vt(s("Tom "),s("is a boy")));
  15. mulmap.insert(vt(s("Tom "),s("is a bad boy of blue!")));
  16. mulmap.insert(vt(s("Jerry "),s("is a student")));
  17. mulmap.insert(vt(s("Jerry "),s("is a beatutiful girl")));
  18. mulmap.insert(vt(s("DJ "),s("is a student")));
  19. //输出初始化以后的多重映射mulmap:
  20. for(p=mulmap.begin();p!=mulmap.end();++p)
  21.    cout<<(*p).first<<(*p).second<<endl;
  22. //检索并输出Jerry键所对应的所有的值
  23. cout<<"find Jerry :"<<endl;
  24. p=mulmap.find(s("Jerry "));
  25. while((*p).first=="Jerry ")
  26. {
  27.        cout<<(*p).first<<(*p).second<<endl;
  28.        ++p;
  29. }
  30. cin.get();
  31. return 0;
  32. }  
复制代码

　　在map中是不允许一个键对应多个值的，在multimap中，不支持operator[],也就是说不支持map中允许的下标操作

算法（algorithm）：#inlcude <algorithm>
　　STL中算法的大部分都不作为某些特定容器类的成员函数，他们是泛型的，每个算法都有处理大量不同容器类中数据的使用。值得注意的是，STL中的算法大多有多种版本，用户可以依照具体的情况选择合适版本。中在STL的泛型算法中有4类基本的算法：

  • 变序型队列算法，可以改变容器内的数据；
  • 非变序型队列算法，处理容器内的数据而不改变他们；
  • 排序值算法，包涵对容器中的值进行排序和合并的算法，还有二叉搜索算法 $$通用数值算法；

注：STL的算法并不只是针对STL容器，对一般容器也是适用的。

变序型队列算法（mutating algorithms）：
　　又叫可修改的序列算法。这类算法有复制（copy）算法、交换（swap）算法、替代（replace）算法、删除（remove）算法，移动（transfer）算法、翻转（reverse）算法等等。这些算法可以改变容器中的数据（数据值和值在容器中的位置）。下面介绍2个比较常用的算法reverse()和copy()。

  1. //stl_cpp_14.cpp
  2. #include <iostream>
  3. #include <algorithm>
  4. #include <iterator>//下面用到了输出迭代器ostream_iterator
  5. using namespace std;
  6. int main(void)
  7. {
  8. int arr[6]={1,12,3,2,1215,90};
  9.       int arr1[7];
  10. int arr2[6]={2,5,6,9,0,-56};
  11. copy(arr,(arr+6),arr1);//将数组aar复制到arr1
  12. cout<<"arr[6] copy to arr1[7],now arr1: "<<endl;
  13.        for(int i=0;i<7;i++)
  14.             cout<<" "<<arr1[i];
  15. reverse(arr,arr+6);//将排好序的arr翻转
  16. cout<<''\n''<<"arr reversed ,now arr:"<<endl;
  17.        copy(arr,arr+6,ostream_iterator<int>(cout, " "));//复制到输出迭代器
  18. swap_ranges(arr,arr+6,arr2);//交换arr和arr2序列
  19.        cout<<''\n''<<"arr swaped to arr2,now arr:"<<endl;
  20.        copy(arr,arr+6,ostream_iterator<int>(cout, " "));
  21.        cout<<''\n''<<"arr2:"<<endl;
  22.        copy(arr2,arr2+6,ostream_iterator<int>(cout, " "));
  23.        cin.get();
  24. return 0;
  25. }
复制代码

revese()的功能是将一个容器内的数据顺序翻转过来，它的原型是：

  1.    template<class Bidirectional >
  2. void reverse(Bidirectional first, Bidirectional last);
复制代码

将first和last之间的元素翻转过来，上例中你也可以只将arr中的一部分进行翻转：

  1. reverse(arr+3,arr+6);//这也是有效的。First和last需要指定一个操作区间。
复制代码

Copy()是要将一个容器内的数据复制到另一个容器内，它的原型是：

  1. Template<class InputIterator ，class OutputIterator>
  2.    OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);
复制代码

　　它把[first,last－1]内的队列成员复制到区间[result,result+(last-first)-1]中。泛型交换算法：Swap()操作的是单值交换，它的原型是：

  1. template<class T>
  2. void swap(T& a,T& b);
复制代码

swap_ranges()操作的是两个相等大小区间中的值，它的原型是：

  1.    template<class ForwardIterator1, class ForwardIterator2>
  2.    ForwardIterator2 swap_ranges(ForwardIterator1 first1,ForwardIterator1 last1, \
  3. ForwardIterator1 first2);
复制代码

　　交换区间[first1,last1-1]和[first2, first2+(last1-first1)-1]之间的值，并假设这两个区间是不重叠的。

非变序型队列算法（Non-mutating algorithm）：
　　又叫不可修改的序列算法。这一类算法操作不影响其操作的容器的内容，包括搜索队列成员算法，等价性检查算法，计算队列成员个数的算法。我将用下面的例子介绍其中的find(),search(),count()：

  1. //stl_cpp_15.cpp
  2. #include <iostream>
  3. #include <vector>
  4. #include <algorithm>
  5. using namespace std;
  6. int main(void)
  7. {
  8. int a[10]={12,31,5,2,23,121,0,89,34,66};
  9. vector<int> v1(a,a+10);
  10. vector<int>::iterator result1,result2;//result1和result2是随机访问迭代器
  11. result1=find(v1.begin(),v1.end(),2);
  12. //在v1中找到2，result1指向v1中的2
  13. result2=find(v1.begin(),v1.end(),8);
  14. //在v1中没有找到8，result2指向的是v1.end()
  15. cout<<result1-v1.begin()<<endl; //3－0＝3或4－1＝3，屏幕结果是3
  16. cout<<result2-v1.end()<<endl;
  17. int b[9]={5,2,23,54,5,5,5,2,2};
  18. vector<int> v2(a+2,a+8);
  19. vector<int> v3(b,b+4);
  20. result1=search(v1.begin(),v1.end(),v2.begin(),v2.end());
  21. cout<<*result1<<endl;
  22. //在v1中找到了序列v2，result1指向v2在v1中开始的位置
  23.     result1=search(v1.begin(),v1.end(),v3.begin(),v3.end());
  24.     cout<<*(result1-1)<<endl;
  25. //在v1中没有找到序列v3，result指向v1.end(),屏幕打印出v1的最后一个元素66
  26.     vector<int> v4(b,b+9);
  27.     int i=count(v4.begin(),v4.end(),5);
  28.     int j=count(v4.begin(),v4.end(),2);
  29.     cout<<"there are "<<i<<" members in v4 equel to 5"<<endl;
  30.     cout<<"there are "<<j<<" members in v4 equel to 2"<<endl;
  31.     //计算v4中有多少个成员等于 5,2
  32. cin.get();
  33. return 0;       
  34. }
复制代码

find()的原型是：

  1. template<class InputIterator，class EqualityComparable>
  2. InputIterator find(InputIterator first, InputIterator last,\
  3.                const EqualityComparable& value);
复制代码

　　其功能是在序列[first,last-1]中查找value值，如果找到，就返回一个指向value在序列中第一次出现的迭代，如果没有找到，就返回一个指向last的迭代（last并不属于序列）。 search()的原型是：

  1. template <class ForwardIterator1, class ForwardIterator2>
  2. ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,\
  3.                      ForwardIterator2 first2, ForwardIterator2 last2);
复制代码

　　其功能是在源序列[first1,last1-1]查找目标序列[first2，last2-1]如果查找成功，就返回一个指向源序列中目标序列出现的首位置的迭代。查找失败则返回一个指向last的迭代。 Count()的原型是：

  1. template <class InputIterator, class EqualityComparable>
  2. iterator_traits<InputIterator>::difference_type count(InputIterator first,\
  3. InputIterator last, const EqualityComparable& value);
复制代码

　　其功能是在序列[first,last-1]中查找出等于value的成员，返回等于value得成员的个数。

排序算法（sort algorithm）：
　　这一类算法很多，功能强大同时也相对复杂一些。这些算法依赖的是关系运算。在这里我只介绍其中比较简单的几种排序算法：sort(),merge(),includes()

  1. //stl_cpp_16.cpp
  2.    #include <iostream>
  3. #include <algorithm>
  4. using namespace std;
  5. int main(void)
  6. {
  7. int a[10]={12,0,5,3,6,8,9,34,32,18};
  8. int b[5]={5,3,6,8,9};
  9. int d[15];
  10. sort(a,a+10);
  11. for(int i=0;i<10;i++)
  12.    cout<<" "<<a[i];
  13. sort(b,b+5);
  14. if(includes(a,a+10,b,b+5))
  15.    cout<<''\n''<<"sorted b members are included in a."<<endl;
  16. else
  17.    cout<<"sorted a dosn`t contain sorted b!";
  18.     merge(a,a+10,b,b+5,d);
  19. for(int j=0;j<15;j++)
  20.    cout<<" "<<d[j];
  21. cin.get();
  22. return 0;
  23. }
复制代码

sort()的原型是：

  1. template <class RandomAccessIterator>
  2. void sort(RandomAccessIterator first, RandomAccessIterator last);
复制代码

　　功能是对[first,last-1]区间内的元素进行排序操作。与之类似的操作还有：partial_sort(), stable_sort()，partial_sort_copy()等等。 merge()的原型是：

  1. template <class InputIterator1, class InputIterator2, class OutputIterator>
  2. OutputIterator merge(InputIterator1 first1, InputIterator1 last1,\
  3.             InputIterator2 first2, InputIterator2 last2,OutputIterator result);
复制代码

　　将有序区间[first1,last1-1]和[first2,last2-1]合并到[result, result + (last1 - first1) + (last2 - first2)-1]区间内。

Includes()的原型是：

  1. template <class InputIterator1, class InputIterator2>
  2. bool includes(InputIterator1 first1, InputIterator1 last1,\
  3.                InputIterator2 first2, InputIterator2 last2);
复制代码

　　其功能是检查有序区间[first2,last2-1]内元素是否都在[first1,last1-1]区间内，返回一个bool值。

通用数值算法（generalized numeric algorithms）
　　这一类算法还不多，涉及到专业领域中有用的算术操作，独立包涵于头文件<numeric>中（HP版本的STL中是<algo.h>）。这里不作介绍。
　　STL中的算法大都有多种版本，常见的版本有以下4中：

  • 默认版本，假设给出了特定操作符；
  • 一般版本，使用了成员提供的操作符；
  • 复制版本，对原队列的副本进行操作，常带有 _copy 后缀；
  • 谓词版本，只应用于满足给定谓词的队列成员，常带有 _if 后缀；

　　以上我们学习了STL容器和算法的概念，以及一些简单的STL容器和算法。在使用算法处理容器内的数据时，需要从一个数据成员移向另一个数据成员，迭代器恰好实现了这一功能。下面我们来学习STL迭代器 。

迭代器（itertor）：#include<iterator>
　　迭代器实际上是一种泛化指针，如果一个迭代器指向了容器中的某一成员，那么迭代器将可以通过自增自减来遍历容器中的所有成员。迭代器是联系容器和算法的媒介，是算法操作容器的接口。在运用算法操作容器的时候，我们常常在不知不觉中已经使用了迭代器。
STL中定义了6种迭代器：

  • 输入迭代器，在容器的连续区间内向前移动，可以读取容器内任意值；
  • 输出迭代器，把值写进它所指向的队列成员中；
  • 前向迭代器，读取队列中的值，并可以向前移动到下一位置（++p,p++）；
  • 双向迭代器，读取队列中的值，并可以向前向后遍历容器；
  • 随机访问迭代器, vector<T>::iterator，list<T>::iterator等都是这种迭代器 ；
  • 流迭代器，可以直接输出、输入流中的值；

　　实际上，在前面的例子中，我们不停的在用迭代器。下面我们用几个例子来帮助理解这些迭代器的用法。
下面的例子用到了输入输出迭代器：

  1. // stl_cpp_17.cpp
  2. #include <iostream>
  3. #include <fstream>
  4. #include <iterator>
  5. #include <vector>
  6. #include <string>
  7. using namespace std;
  8. int main(void)
  9. {
  10. vector<string> v1;
  11. ifstream file("Text1.txt");
  12. if(file.fail())
  13. {
  14.    cout<<"open file Text1.txt failed"<<endl;
  15.    return 1;
  16. }
  17.    copy(istream_iterator<string>(file),istream_iterator<string>(),inserter(v1,\
  18. v1.begin()));
  19. copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));
  20. cout<<endl;
  21. cin.get();
  22. return 0;
  23. }
复制代码

　　这里用到了输入迭代器istream_iterator，输出迭代器ostream_iterator。程序完成了将一个文件输出到屏幕的功能，先将文件读入，然后通过输入迭代器把文件内容复制到类型为字符串的向量容器内，最后由输出迭代器输出。Inserter是一个输入迭代器的一个函数(迭代器适配器)，它的使用方法是：

  2. inserter (container ,pos);
复制代码

　　congtainer是将要用来存入数据的容器，pos是容器存入数据的开始位置。上例中，是把文件内容存入（copy()）到向量v1中。

现在我们已经对STL的三大基本组件有了一个大概的了解，下面让我们一起来看看STL的其他标准组件

函数对象（functor或者funtion objects）：#include <function>
　　函数对象又称之为仿函数。函数对象将函数封装在一个对象中，使得它可作为参数传递给合适的STL算法，从而使算法的功能得以扩展。可以把它当作函数来使用。用户也可以定义自己的函数对象。下面让我们来定义一个自己的函数对象。
  1. // stl_cpp_18.cpp
  2. #include <iostream>
  3. using namespace std;
  4. struct int_max{
  5. int operator()(int x,int y){return x>y?x:y; }
  6. };//operator() 重载了"（）"， (int x,int y)是参数列表
  7. int main(void)
  8. {
  9. cout<<int_max()(3,4)<<endl;
  10. cin.get();
  11. return 0;
  12. }
复制代码
　　这里的int_max（）就是一个函数对象，struct关键字也可以用class来代替，只不过struct默认情况下是公有访问权限，而class定义的是默认私有访问权限。下面我们来定义一个STL风格的函数对象：
  1. // stl_cpp_19.cpp
  2. #include <iostream>
  3. #include <vector>
  4. using namespace std;
  5. struct adder : public unary_function<double, void>
  6. {
  7.    adder() : sum(0) {}
  8.    double sum;
  9.    void operator()(double x) { sum += x; }
  10. };
  11. int main(void)
  12. {
  13. double a[5]={0.5644,1.1,6.6,8.8,9.9};
  14. vector<double> V(a,a+5);
  15. adder result = for_each(V.begin(), V.end(), adder());
  16. cout << "The sum is " << result.sum << endl;
  17. cin.get();
  18. return 0;
  19. }
复制代码
　　在这里，我们定义了一个函数对象adder()，这也是一个类，它的基类是unary_function函数对象。unary_function是一个空基类，不包涵任何操作或变量。只是一种格式说明，它有两个参数，第一个参数是函数对象的使用数据类型，第二个参数是它的返回类型。基于它所定义的函数对象是一元函数对象。（注：用关键字struct或者class定义的类型实际上都是"类"）
　　STL内定义了各种函数对象，否定器、约束器、一元谓词、二元谓词都是常用的函数对象。函数对象对于编程来说很重要，因为他如同对象类型的抽象一样作用于操作。

适配器（adapter）：
　　适配器是用来修改其他组件接口的STL组件，是带有一个参数的类模板（这个参数是操作的值的数据类型）。STL定义了3种形式的适配器：容器适配器，迭代器适配器，函数适配器。
  • 容器适配器：包括栈（stack）、队列(queue)、优先(priority_queue)。使用容器适配器，stack就可以被实现为基本容器类型（vector,dequeue,list）的适配。可以把stack看作是某种特殊的vctor,deque或者list容器，只是其操作仍然受到stack本身属性的限制。queue和priority_queue与之类似。容器适配器的接口更为简单，只是受限比一般容器要多；
  • 迭代器适配器：修改为某些基本容器定义的迭代器的接口的一种STL组件。反向迭代器和插入迭代器都属于迭代器适配器，迭代器适配器扩展了迭代器的功能；
  • 函数适配器：通过转换或者修改其他函数对象使其功能得到扩展。这一类适配器有否定器（相当于"非"操作）、帮定器、函数指针适配器。
结束语
　　如果你理解了算法、迭代器、容器，那么你几乎就了解了 STL。关于STL的其他方面，新手都是不常用的，可以暂时以理解STL的组成的编程思想为主。这篇文章里用到了19个cpp代码，每个代码都在Windows 2000+ Dev-C++ 4.9.9.0和windows 2000＋VC环境下通过编译运行。读者可以通过copy/paste到任何一款C++编译器中运行。无论你想不想学STL，先运行一下STL代码吧。编程快乐，好好学习，天天向上。

我是新手，欢迎高手批评，欢迎STL学习者交流： Email：taohanjunjiang@yahoo.com.cn QQ:370679790
【附录】

附录一：Dev-C++ 和VC
　　在Dev-C++ 4.9.9.0 +windows 2000下，不允许出现,void main(){} 而必须为 int main() {return 0;} ,或者 int main(){},奇怪的是VC对 int main(){} 的写法会提出警告，而必须为 int main() {return 0;}。建议使用标准格式 int main(void) {……return 0;}
　　Dev-C++而且不支持头文件方式，#include <iostream.h>是不对的，而必须为#include <iostream> using namespace std; VC两种格式都支持。建议使用#include <iostream> using namespace std;
　　如果用纯C/C++编程，建议使用比较简单的C++编译器，甚至是命令行下的编译方式。功能强大的IDE甚至会误导编程者。还要花费不少的时间来学习使用IDE开发环境。Dev比VC要简单一些，只是不适合做大型工程，而且编译时间比VC稍慢一点，纯C++编程建议使用。他有插入时间和头文件注释模板的功能，作者可以方便地插入编程、程序更改时间，方便地填写程序说明信息。
　　在Dev下可以导入VC工程，而且保持原来的VC工程文件，但是Dev对VC的支持还不够，在编译的时候会遇到错误。
　　在编写dos程序的时候，建议在程序的末尾return之前加上：getchar();cin.get();之类的代码，以方便看运行结果。

附录二：中小型程序段的编辑工具
　　在编辑程序过程中并不一定非要在特定的IDE环境中，在有些专业化的文本编辑工具中编辑代码会更有利于代码的修改和编辑。这里介绍几种更能比较强大的文本编辑器。
  • UltraEdit-32；
  • EditPlus；
  • SourceInsight；
  • Vim；

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/macula7/p/1960670.html