STL容器函数资料

第一类容器(支持迭代器)

❀序列容器

Vector(随机迭代访问)

【向量】

说明：

vector是一种动态数组，是基本数组的类模板。其内部定义了很多基本操作。

＃include <vector> 注意：头文件没有“.h”

构造：

vector<int> v1; // 默认构造函数

vector<int> v2(init_size,0); //如果预先定义了：int init_size;他的成员值都被初始化为0；

vector<int> v3(v2); // 复制构造函数，构造一个新的向量，作为已存在的向量的完全复制;

vector<int> v4(first, last) // 带两个常量参数的构造函数，产生初始值为一个区间的向量。区间由一个半开区间      [first, last) 来指定。

方法：

assign(beg,end) 将(beg; end)区间中的数据赋值给对象。

assign(n,elem)将n个elem的拷贝赋值给对象。

at(idx)传回索引idx所指的数据，如果idx越界，抛出out_of_range。

back()传回最后一个数据，不检查这个数据是否存在。

begin()传回迭代器中的第一个数据地址。

capacity()返回容器中数据个数。

clear()移除容器中所有数据。

empty()判断容器是否为空。

end() // 指向迭代器中末端元素的下一个，指向一个不存在元素。

erase(pos) // 删除pos位置的数据，传回下一个数据的位置。

erase(beg,end)删除[beg,end)区间的数据，传回下一个数据的位置。

front()传回第一个数据。

get_allocator使用构造函数返回一个拷贝。

insert(pos,elem) // 在pos位置插入一个elem拷贝，传回新数据位置

insert(pos,n,elem) // 在pos位置插入n个elem数据,无返回值

insert(pos,beg,end) // 在pos位置插入在[beg,end)区间的数据。无返回值

max_size()返回容器中最大数据的数量。

pop_back()删除最后一个数据。

push_back(elem)在尾部加入一个数据。

rbegin()传回一个逆向队列的第一个数据。

rend()传回一个逆向队列的最后一个数据的下一个位置。

resize(num)重新指定队列的长度。

reserve()保留适当的容量。

size()返回容器中实际数据的个数。

c1.swap(c2) // 将c1和c2元素互换

Deque(随机迭代访问)

【双队列】

说明

#include <deque>

deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。

构造：

deque<Elem> c 创建一个空的deque

deque<Elem> c1(c2) 复制一个deque。

deque<Elem> c(n) 创建一个deque，含有n个数据，数据均已缺省构造产生。

deque<Elem> c(n, elem) 创建一个含有n个elem拷贝的deque

deque<Elem> c(beg,end) 创建一个以[beg;end)区间的deque

~deque<Elem>() 销毁所有数据，释放内存

方法：

assign(beg, end) 将[beg; end)区间中的数据赋值给对象。

assign(n, elem) 将n个elem的拷贝赋值给对象。

at(index) 传回索引index所指的数据，如果index越界，抛出out_of_range。

back() 传回最后一个数据，不检查这个数据是否存在。

begin() 传回迭代器重的可一个数据。

clear() 移除容器中所有数据。

empty() 判断容器是否为空。

end() 指向迭代器中的最后一个数据地址。

erase(pos) 删除pos位置的数据，传回下一个数据的位置。

erase(beg,end) 删除[beg,end)区间的数据，传回下一个数据的位置。

front() 传回第一个数据。

get_allocator 使用构造函数返回一个拷贝。

insert(pos,elem) 在pos位置插入一个elem拷贝，传回新数据位置

insert(pos,n,elem) 在pos位置插入>n个elem数据。无返回值

insert(pos,beg,end) 在pos位置插入在[beg,end)区间的数据。无返回值

max_size() 返回容器中最大数据的数量。

pop_back() 删除最后一个数据。

pop_front() 删除头部数据。

push_back(elem) 在尾部加入一个数据。

push_front(elem) 在头部插入一个数据。

rbegin() 传回一个逆向队列的第一个数据。

rend() 传回一个逆向队列的最后一个数据的下一个位置。

resize(num) 重新指定队列的长度。

size() 返回容器中实际数据的个数。

swap(c2)

swap(c1,c2) 将c1和c2元素互换。

List(双向迭代访问)

【列表】

说明：

就是一双向链表，可高效地进行插入删除元素。包括构造、方法等。

构造：

list<int> c0; //空链表

list<int> c1(3); //建一个含三个默认值是0的元素的链表

list<int> c2(5,2); //建一个含五个元素的链表，值都是2

list<int> c4(c2); //建一个c2的copy链表

list<int> c5(c1.begin(),c1.end()); //c5含c1一个区域的元素[First,Last)。

方法：

assign() //分配值，有两个重载：

c1.assign(++c2.begin(),c2.end())//c1现在为(50,60)。

c1.assign(7,4) //c1中现在为7个4,c1(4,4,4,4,4,4,4)。

back() //返回最后一元素的引用：

begin() //返回第一个元素的指针(iterator)

clear() //删除所有元素

empty() //判断是否链表为空

end() //返回最后一个元素的下一位置的指针(list为空时end()=begin())

erase() //删除一个元素或一个区域的元素(两个重载)

front() //返回第一个元素的引用：

insert() //在指定位置插入一个或多个元素(三个重载)：

max_size() //返回链表最大可能长度(size_type就是int型)：

merge() //合并两个链表并使之默认升序(也可改)：

pop_back() //删除链表尾的一个元素

pop_front() //删除链表头的一元素

push_back() //增加一元素到链表尾

push_front() //增加一元素到链表头

rbegin() //返回链表最后一元素的后向指针(reverse_iterator or const)

rend() //返回链表第一元素的下一位置的后向指针

remove //()删除链表中匹配值的元素(匹配元素全部删除)

remove_if() //删除条件满足的元素(会遍历一遍链表)

resize() //重新定义链表长度(两重载)：

reverse() //反转链表:

size() //返回链表中元素个数

sort() //对链表排序，默认升序(可自定义)

splice() //对两个链表进行结合(三个重载)

swap() //交换两个链表(两个重载)

unique() //删除相邻重复元素(断言已经排序，因为它不会删除不相邻的相同元素)

❀关联容器

Set和multiset(双向迭代访问)

【集合、多重集合】

集和多集（set 和multiset容器类）

#include <set>

一个集合（set）是一个容器，它其中所包含的元素的值是唯一的。

set和multiset的区别是：set支持唯一键值，set中的值都是特定的，而且只出现一次；而multiset中可以出现副本键，同一值可以出现多次。

说明：

由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序.

构造

explicit set(const Compare&=compare());

如：set<int,less<int> > set1;

less<int>是一个标准类，用于形成升序排列函数对象。降序排列是用greater<int>。

Template<class InputIterator>set(InputIterator, InputIterator, const Compare&=compare());

如：set<int ,less<int>>set2(vector1.begin(),vector1.end());

通过指定某一预先定义的区间来初始化set对象的构造函数。

set（const set<Key,Compare&>）;

如：set<int ,less<int>>set3(set2);

方法：

begin() 返回指向第一个元素的迭代器

clear() 清除所有元素

count() 返回某个值元素的个数

empty() 如果集合为空，返回true

end() 返回指向最后一个元素之后的迭代器，不是最后一个元素

equal_range() 返回集合中与给定值相等的上下限的两个迭代器

erase() 删除集合中的元素

find() 返回一个指向被查找到元素的迭代器

get_allocator() 返回集合的分配器

insert() 在集合中插入元素

lower_bound() 返回指向大于（或等于）某值的第一个元素的迭代器

key_comp() 返回一个用于元素间值比较的函数

max_size() 返回集合能容纳的元素的最大限值

rbegin() 返回指向集合中最后一个元素的反向迭代器

rend() 返回指向集合中第一个元素的反向迭代器

size() 集合中元素的数目

swap() 交换两个集合变量

upper_bound() 返回大于某个值元素的迭代器

value_comp() 返回一个用于比较元素间的值的函数

Map和multimap(双向迭代访问)

【映射、多重映射】

映射和多重映射基于某一类型Key的键集的存在，提供对T类型的数据进行快速和高效的检索。对map而言，键只是指存储在容器中的某一成员。Map不支持副本键，multimap支持副本键。Map和multimap对象包涵了键和各个键有关的值，键和值的数据类型是不相同的，这与set不同。set中的key和value是Key类型的，而map中的key和value是一个pair结构中的两个分量。

1.map介绍

使用map得包含map类所在的头文件：

#include <map>

1.1 map的构造

Template<class T1, class T2>

map(); // 默认构造函数

map(const map& m) // 拷贝构造函数

map(iterator begin, iterator end ); //区间构造函数

map(iterator begin, iterator end, consttraits& _compare) //带比较谓词的构造函数

map(iterator begin, iterator end, consttraits& _compare, const allocator& all) //带分配器

1.2 map定义

1.2.1 map的基本定义

map对象是模板类，需要关键字和存储对象两个模板参数：

std:map<int, string> personnel;

这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.

为了使用方便，可以对模板类进行一下类型定义：

typedef map<int, CString>UDT_MAP_INT_CSTRING;

UDT_MAP_INT_CSTRING enumMap; //后面会依此例说明

1.2.2 map的嵌套定义

map<sring,map<string,long> > //注意：最后两个>之间有个空格

map支持下标运算符operator[]，用访问普通数组的方式来访问map；不过下标为map的键，在multimap中一个键可以对应多个不同的值。

2.map的方法

2.1 在map中插入元素

三种插入方式：

2.1.1用insert方法插入pair对象：

enumMap.insert(pair<int, Cstring>(1,“One”));

2.1.2 用insert方法插入value_type对象：

enumMap.insert(map<int,Cstring>::value_type (1, “One”));

2.1.3 用数组方式插入值：

enumMap[1] = "One";

enumMap[2] = "Two";

......

这样非常直观，但存在一个性能的问题。插入2时,先在enumMap中查找主键为2的项，没发现，然后将一个新的对象插入enumMap，键是2，值是一个空字符串，插入完成后，将字符串赋为"Two"; 该方法会将每个值都赋为缺省值，然后再赋为显示的值，如果元素是类对象，则开销比较大。用前两种方法可以避免开销。

2.2 查找并获取map中元素

2.2.1下标操作符给出了获得一个值的最简单方法：

CString tmp = enumMap[2];

但是,只有当map中有这个键的实例时才对，否则会自动插入一个实例，值为初始化值。

2.2.2我们可以使用find()和count()方法来发现一个键是否存在

查找map中是否包含某个关键字条目用find()方法，传入的参数是要查找的key，在这里需要提到的是begin()和end()两个成员，分别代表map对象中第一个条目和最后一个条目，这两个数据的类型是iterator.

int nFindKey = 2; //要查找的Key

//定义一个条目变量(实际是指针)

UDT_MAP_INT_CSTRING::iterator it=enumMap.find(nFindKey);

if(it == enumMap.end()) {

cout<<"没找到"<<endl;

}

else {

cout<<"找到了"<<endl;

}

通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据。

iterator->first 关键字(key)

iterator->second 存储的数据(value)

2.3 从map中删除元素

2.3.1移除某个map中某个条目用erase()

该成员方法的定义如下：

1．iterator erase(iterator it); //通过一个条目对象删除

2．iterator erase(iterator first, iterator last); //删除一个范围

3．size_type erase(const Key& key); //通过关键字删除

2.3.2清除所有的元素clear()

clear()就相当于 enumMap.erase(enumMap.begin(), enumMap.end());

2.4 map中swap的用法

map中的swap不是一个容器中的元素交换，而是两个容器交换；

For example：

#include <map>

#include <iostream>

using namespace std;

int main( )

{

map <int, int> m1, m2, m3;

map <int, int>::iterator m1_Iter;

m1.insert ( pair <int, int> ( 1, 10 ));

m1.insert ( pair <int, int> ( 2, 20 ));

m1.insert ( pair <int, int> ( 3, 30 ));

m2.insert ( pair <int, int> ( 10, 100 ));

m2.insert ( pair <int, int> ( 20, 200 ));

m3.insert ( pair <int, int> ( 30, 300 ));

cout << "The original map m1is:";

for ( m1_Iter = m1.begin( ); m1_Iter !=m1.end( ); m1_Iter++ )

cout << " " <<m1_Iter->second;

cout << "." << endl;

// This is the member function version ofswap

//m2 is said to be the argument map; m1 thetarget map

m1.swap( m2 );

cout << "After swapping with m2,map m1 is:";

for ( m1_Iter = m1.begin( ); m1_Iter !=m1.end( ); m1_Iter++ )

cout << " " << m1_Iter-> second;

cout << "." << endl;

cout << "After swapping with m2,map m2 is:";

for ( m1_Iter = m2.begin( ); m1_Iter !=m2.end( ); m1_Iter++ )

cout << " " << m1_Iter-> second;

cout << "." << endl;

// This is the specialized template versionof swap

swap( m1, m3 );

cout << "After swapping with m3,map m1 is:";

for ( m1_Iter = m1.begin( ); m1_Iter !=m1.end( ); m1_Iter++ )

cout << " " << m1_Iter-> second;

cout << "." << endl;

}

2.5 map的sort问题

Map中的元素是自动按key升序排序,所以不能对map用sort函数：

For example：

#include <map>

#include <iostream>

using namespace std;

int main( )

{

map <int, int> m1;

map <int, int>::iterator m1_Iter;

m1.insert ( pair <int, int> ( 1, 20 ));

m1.insert ( pair <int, int> ( 4, 40 ));

m1.insert ( pair <int, int> ( 3, 60 ));

m1.insert ( pair <int, int> ( 2, 50 ));

m1.insert ( pair <int, int> ( 6, 40 ));

m1.insert ( pair <int, int> ( 7, 30 ));

cout << "The original map m1is:"<<endl;

for ( m1_Iter = m1.begin( ); m1_Iter !=m1.end( ); m1_Iter++ )

cout << m1_Iter->first<<""<<m1_Iter->second<<endl;

}

The original map m1 is:

1 20

2 50

3 60

4 40

6 40

7 30

请按任意键继续. . .

2.6 map的基本操作函数

C++Maps是一种关联式容器，包含“关键字/值”对

begin() 返回指向map头部的迭代器

clear(） 删除所有元素

count() 返回指定元素出现的次数

empty() 如果map为空则返回true

end() 返回指向map末尾的迭代器

equal_range() 返回特殊条目的迭代器对

erase() 删除一个元素

find() 查找一个元素

get_allocator() 返回map的配置器

insert() 插入元素

key_comp() 返回比较元素key的函数

lower_bound() 返回键值>=给定元素的第一个位置

max_size() 返回可以容纳的最大元素个数

rbegin() 返回一个指向map尾部的逆向迭代器

rend() 返回一个指向map头部的逆向迭代器

size() 返回map中元素的个数

swap() 交换两个map

upper_bound() 返回键值>给定元素的第一个位置

value_comp() 返回比较元素value的函数

容器适配器(不支持迭代器)

Stack

【栈】

说明：

Stack(堆栈)是一个容器类的改编，为程序员提供了堆栈的全部功能，也就是说实现了一个先进后出的数据结构(FILO）。

#include <stack>

方法：

主要有一下几个函数：

empty() 如当前堆栈为空，empty()函数返回true,否则返回false.

pop() 函数移除堆栈中最顶层元素。

push() 向栈顶添加一个元素。

size() 函数返当前堆栈中的元素数目。

top() 函数返回栈顶元素的引用。

Queue

【队列】

说明：

队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列，遵循先进先出原则（FIFO）。

方法：

back() 返回队列最后一个元素的引用

front() 返回队列第一个元素的引用

empty() 检查队列是否为空

pop() 从队首删除一个元素

push() 从队尾插入一个元素

size() 返回队列元素的个数

Priority_queue

【优先队列】

说明：

优先级最高的元素最先出队

方法：

empty() 检查队列是否为空

pop() 从队首删除一个元素

push() 从队尾插入一个元素

size() 返回队列元素的个数

top() 返回队首最大元素的const引用