顺序容器中所有的元素在容器中的物理位置都是按照特定的次序进行存放的，区别于关联容器的是顺序容器中的元素的位置都是既定的。被纳入STL标准的顺序容器包括vector、list、dequeue。
序列容器之间的共性除了容器之间应有的共性之外，还有对数据操作的接口(非实现)上：
c.push_back
c.pop_back
c.push_front
c.pop_front
c.back
c.front
c.erase
c.remove
vector和数组具有同样的内存处理方式。不同于数组的是：数组是静态空间，一旦分配了就不能被改变，因而空间的分配非常地不灵活；vector是动态空间，即空间可以被动态分配，因而空间的分配很灵活。可以说vector是相对数组的一种更高级的数据结构。（vector通过预先分配存储空间，当空间占用满后，自动重新分配更多的存储空间实现动态分配，因此具有capacity属性）
vector中的迭代器的种类为随机存取迭代器(random-access-iterator)。
vector不同于其它顺序容器(Sequence Container) 的时，它具有capacity属性，可以通过vec.capacity()来获取。
请看下面的例子：
构造vector
int ia[] = {123,343,12,100,343,5,5};
vector<int> vec(ia,ia+7);//{ 123,343,12,100,343,5,5}
vector<int> vec1(2,4);//{4,4}
vector<int> vec2(4);{0,0,0,0}
输出vector中的所有数据
vector<int>::iterator itEnd = vec.end();
for(vector<int>::iterator it = vec.begin(); it != itEnd; ++it)
std::cout << *it << endl;
添加数据
vector<int>::iterator it(vec.rbegin().base());
vec.insert(it,1);
或
vector<int>::iterator it = vec.begin();
vec.insert(it,1);
list是链表的抽象数据结构(ADT)。list中的所有数据在空间分配上不一定是连续存放的。相对vector，list没有capaciy属性。
list中的迭代器的种类为双向存取迭代器(bidirectional -access-iterator)。
请看下面的例子：
构造list
int ia[] = {123,343,12,100,343,5,5};
list<int> ls;
list<int> ls(ia,ia+7); //{ 123,343,12,100,343,5,5}
list<int> ls(2,4); //{4,4}
list<int> ls(4);{ 0,0,0,0}
输出list中的所有数据
list<int>::iterator itEnd = ls.end();
for(list<int>::iterator it = ls.begin(); it != itEnd; ++it)
std::cout << *it << endl;
deque，即双向链表。相对vector，deque也是连续空间，但不是vector的连续线性空间。
deque中的迭代器的种类为随机存取迭代器(random-access-iterator)。
deque成员函数如下表：
|
函数
|
描述
|
|
c.assign(beg,end)
c.assign(n,elem)
|
将[beg; end)区间中的数据赋值给c。
将n个elem的拷贝赋值给c。
|
|
c.at(idx)
|
传回索引idx所指的数据，如果idx越界，抛出out_of_range。
|
|
c.back()
|
传回最后一个数据，不检查这个数据是否存在。
|
|
c.begin()
|
传回迭代器重的可一个数据。
|
|
c.clear()
|
移除容器中所有数据。
|
|
deque<Elem> c
deque<Elem> c1(c2)
deque<Elem> c(n)
deque<Elem> c(n, elem)
deque<Elem> c(beg,end)
c.~deque<Elem>()
|
创建一个空的deque。
复制一个deque。
创建一个deque，含有n个数据，数据均已缺省构造产生。
创建一个含有n个elem拷贝的deque。
创建一个以[beg;end)区间的deque。
销毁所有数据，释放内存。
|
|
c.empty()
|
判断容器是否为空。
|
|
c.end()
|
指向迭代器中的最后一个数据地址。
|
|
c.erase(pos)
c.erase(beg,end)
|
删除pos位置的数据，传回下一个数据的位置。
删除[beg,end)区间的数据，传回下一个数据的位置。
|
|
c.front()
|
传回地一个数据。
|
|
c.get_allocator
|
使用构造函数返回一个拷贝。
|
|
c.insert(pos,elem)
c.insert(pos,n,elem)
c.insert(pos,beg,end)
|
在pos位置插入一个elem拷贝，传回新数据位置。
在pos位置插入>n个elem数据。无返回值。
在pos位置插入在[beg,end)区间的数据。无返回值。
|
|
c.max_size()
|
返回容器中最大数据的数量。
|
|
c.pop_back()
|
删除最后一个数据。
|
|
c.pop_front()
|
删除头部数据。
|
|
c.push_back(elem)
|
在尾部加入一个数据。
|
|
c.push_front(elem)
|
在头部插入一个数据。
|
|
c.rbegin()
|
传回一个逆向队列的第一个数据。
|
|
c.rend()
|
传回一个逆向队列的最后一个数据的下一个位置。
|
|
c.resize(num)
|
重新指定队列的长度。
|
|
c.size()
|
返回容器中实际数据的个数。
|
|
C1.swap(c2)
|
将c1和c2元素互换。
|
关联容器(Associative Container)提供了根据key快速检索数据的能力。在关联容器(Associative Container)中，key和元素都是成对(pair)存在的,你可以调用std::make_pair使用key和元素值来构建一个pair。
STL提供的关联容器包括set、multiset、map、multimap。
set和map只支持唯一键(unique key)，即对个key最多只保存一个元素。multiset和multimap则支持多个key，一个key可以对应多个元素。
set和map的区别在于，在set里面key和元素是同一个值，而在map里面key和元素分开存储。（在set中，key和元素是同一个值）
set是集合的抽象数据结构(ADT)。不同于数学意义上的集合，STL中的set的所有的元素都是有序的而且set中所有的元素都是唯一的。
set中的迭代器的种类为双向存取迭代器(bidirectional-access-iterator)。
请看下面的例子：
构建一个set
set<string> fruits;
往set中添加数据
fruits.insert("apple");
fruits.insert("orange");
fruits.insert("banana");
输出set
set<string>::iterator itEnd = fruits.end();
for (set<string>::iterator it=fruits.begin(); it != itEnd; it++)
cout << *it << " ";
输出结果
apple banana orange
multiset和set基本相同，所不同的是，一个multiset中的元素是可以重复的。
multiset中的迭代器的种类为双向存取迭代器(bidirectional-access-iterator)。
multiset的操作同set。
请看下面的例子：
构建一个set
set<string> fruits;
往set中添加数据
fruits.insert("apple");
fruits.insert("orange");
fruits.insert("apple");
fruits.insert("banana");
fruits.insert("banana");
输出set
set<string>::iterator itEnd = fruits.end();
for (set<string>::iterator it=fruits.begin(); it != itEnd; it++)
cout << *it << " ";
输出结果
apple apple banana banana orange
map是字典的抽象数据结构(ADT)。map中的所有的元素都会根据key自动进行排序，而且所有的元素都是唯一的。map中的所有的元素都是pair，即键(key)和值(value)组成的序列(pair中的第一个元素为key，第二个元素为value)。
map中的迭代器的种类为双向存取迭代器(bidirectional-access-iterator)。
请看下面的例子：
构建一个map
typedef std::map<int,string> EMPLOYEE_MAP;
EMPLOYEE_MAP employees;
往map中添加数据
employees.insert(EMPLOYEE_MAP::value_type(25301, "A"));
employees.insert(EMPLOYEE_MAP::value_type(25302, "B"));
employees.insert(EMPLOYEE_MAP::value_type(25303, "C"));
employees.insert(EMPLOYEE_MAP::value_type(25304, "D"));
employees.insert(EMPLOYEE_MAP::value_type(25305, "E"));
输出map
EMPLOYEE_MAP::iterator itEnd = employees.end();
for (EMPLOYEE_MAP::iterator it = employees.begin(); it != itEnd; ++it)
{
std::cout << it->first << "-";
std::cout << it->second << endl;
}
输出结果
25301-A
25302-B
25303-C
25304-D
25305-E
multimap和map基本相同，所不同的是，一个multimap中的key可以重复。
multimap中的迭代器的种类为双向存取迭代器(bidirectional-access-iterator)。
multimap的操作同set。
这里要提到的就是hashtable，即哈希表的抽象数据结构(ADT)。
因为hashtable不是STL标准的一部分，部分编译器(如Microsoft Visual C++)并没有提供hashtable的实现。
hashtable中的迭代器的种类为前向迭代器(forward-iterator)。
在SGI的STL中，有hashtable的实现，其中的hash_set,hash_map,hash_multiset,
hash_multimap都是基于hashtable而构建的，是hashtable的适配器(Adaptor)。而在
Microsoft Visual C++的STL中，并没有提供STL的实现。其中的hash_set,hash_map,hash_multiset,hash_multimap都是基于STL中的hash算法而构建的。
hash_set的操作基本同set；
hash_map的操作基本同map；
hash_multiset的操作基本同multiset；
hash_multimap的操作基本同multimap。
STL中的算法以迭代器为参数，通过作用于迭代器而达到处理容器数据的目的。所有的算法都前两个参数都是以对迭代器（iterator），通常称为first和last。事实上，算法所处理的迭代器范围为[first,last)，如果first==last则表明此范围为空。按照处理问题的不同，STL算法可分为四组，分别是：
1.
不改变序列的算法(None-mutating sequence Algorithm)
2.
改变序列的算法(Mutating sequence Algorithm)
3.
排序以及相关算法(Sorting and related Algorithm)
4.
常用数字算法(Generalized numeric Algorithm)
很多算法都有if版本，如remove_if，这类算法会根据判断条件进行相应的操作；有一些算法具有copy_if或copy版本，不同于非copy_if或copy版本的是，这些操作将获取的值改写另外的迭代器。
本文并不打算对这些算法作详细的介绍，只是对这些算法做简单性的描述。更多的内容，推荐参考《C++ Primer》或《STL和泛型程序设计》。
这类算法以输入迭代器(input-iterator)为输入参数，但不改写迭代器迭代器范围内的数据。典型的算法有：find、count、equal、search、for_each等。
这类算法以输入迭代器(input-iterator)为输入参数，往往还带有一个输出迭代器(output-iterator)，对输入迭代器(input-iterator)处理的结果写入输出迭代器。典型的算法有：copy、transform、remove、rotate、reverse、fill、replace等。
这类算法往往以双向迭代器(bidirectional-iterator)为输入输出参数，对迭代器范围内的数据进行排序，最终序列里面的值都会发生改变。之所以把排序以及相关算法和”不改变序列的算法”分离出来是因为这类算法解决了是算法领域的一类问题，而且这类问题在算法领域的重要性异常突出。典型的算法有：sort、partial_sort、nth_element、qsort、stable_sort、partition、merge、inplace_merge等。
这类算法往往以双向迭代器(bidirectional-iterator)为输入输出参数，对迭代器范围内的数据进行数字操作(如内积等)，最终序列里面的值都会发生改变。这类算法解决的是数学领域相关的问题，因此被划为一类。典型的算法有：next_permutation、pre_permutation、inner_product等。
6. 适配器(Adaptor)
适配器(Adaptor)是为了增强功能或/和添加约束，对容器、迭代器、算法重新进行了包装的模板类。设计模式中的Decorate模式的基本思想是实现适配器(Adaptor)的理论/实践基础。在STL中，适配器可分为三类：容器适配器、迭代器适配器以及算法适配器。
容器适配器是对特定的容器进行Decorate而形成的新的模板类。常见的容器适配器有：
1.
vector适配器
stack：堆栈，是一种FILO的数据结构。
2.
deque适配器
priority_queue：优先级队列，队列里面的所有数据都是按照优先级进行排序的。
queue：单向队列。
3.
list适配器
slist：单向链表。
4.
hashtable的适配器
hash_map,hash_set,hash_multimap,hash_multiset
迭代器适配器是对特定的迭代器进行Decorate而形成的新的模板类。常见的迭代器适配器有：
1.
反向迭代器(reverse iterator)
相对迭代器(iterator)，反向迭代器(reverse iterator)是按照相反的顺序对容器的数据进行访问的，如
vector<int>::reverse_iterator ritBegin = vec.rbegin();
vector<int>::reverse_iterator ritEnd = vec.rend();
2.
插入迭代器(insert iterator)
插入迭代器简化了向容器中插入元素的工作，指定了向容器中插入元素的位置。STL中有三种插入迭代器：
n 前向插入迭代器
在容器的前面插入元素，如调用容器的push_front
n 后向插入迭代器
在容器的后面插入元素，如调用容器的push_back
n 任意插入迭代器
在容器的任意位置插入元素，如调用容器的insert
3.
原始存储迭代器(raw storage itertor)
允许算法将其结果保存到没有初始化的内存中。
函数对象适配器是对某类特定函数对象进行Decorate而形成的新的模板类。常见的迭代器适配器有：
1.
否定者 (negator)
STL中有两个否定者not1和not2，分别对一元和二元谓词(predicate)的执行结果取反。
2.
绑定者(Binder)
STL中有两个绑定者binder1st和binder2nd(你可以通过调用函数bind1st和bind2nd分别构建这两个绑定者)，分别将特定值绑定到函数对象的第1个和第2个参数s。
3.
函数指针函数适配器(Adaptors for pointers to function)
因为STL中的算法一般都使用函数对象作为参数。如果需要使用原始的函数指针用于这些算法的输入参数，那么我们就需要将这些原始指针转化成特定的函数对象。STL提供了这样的转换函数，包括：
n 转化成员函数：mem_fun，mem_fun_ref，mem_fun1，mem_fun1_ref
n 转化非成员函数：ptr_fun
扫一扫
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
