STL模板库

STL模板库

STL是Standard Template Library缩写，中文名字叫标准库模板，由惠普实验室提供，共有三类内容：

算法：以函数模板形式实现的常用算法，如：max、min、swap、find、sort

容器：以类模板形式实现的常用数据结构，如：栈、队列、链式表、顺序表、红黑树

迭代器：它是容器的成员，用于帮助访问容器中的元素，使用方法类似于指针

find

#include <algorithm>
iterator find( iterator start, iterator end, const TYPE& val );
功能：顺序查找
start：第一个元素的指针或迭代器(将链式结构封装成顺序表)
end：最后一个元素的下一个位置
val：待查找的关键数据
返回值：
	找到[start，end) 范围的指针或迭代器
	找不到返回end

sort

#include <algorithm>
void sort( iterator start, iterator end ); //普通类型
void sort( iterator start, iterator end, StrictWeakOrdering cmp );
功能：快速排序
start：第一个元素的指针或迭代器
end：最后一个元素的下一个位置
cmp：
	bool cmp(T a,T b)
	{
		return a>b;
	}

vector向量容器

头文件：vector

采用顺序结构的内存存储数据，可以通过下标随机访问，因此也被称为数组容器

定义向量容器对象时，不需要设置数组长度，它会随着元素添加(push_back)自动扩展内存，每次扩展一倍

构造函数：

vector( const vector& c );

vector( **size_type** num, const TYPE& val = TYPE() );
num：数组长度
val：初始化数据

vector( input_iterator start, input_iterator end );
功能：使用一组数据初始化数组
start：第一个元素
end：最后一个元素的下一个位置

支持的运算符：

==、!=

<=、>=、<、> 按照字符串的比较规则进行比较的

[] 下标 >= sizeof() 就会出现段错误，数组不会随着访问而扩展内存，而是添加元素才扩展

常用的成员函数：

void assign( size_type num, const TYPE& val );
功能：给数组的前num个元素赋值为val

void assign( input_iterator start, input_iterator end );
功能：使用一组数据给数组赋值

TYPE at(size_type loc);
功能：访问数组成员，功能相当于[]，当loc越界时，at函数会抛出异常，而[]越界时可能出现段错误、脏数据、一切正常

TYPE back();
功能：返回数组中的最后一个元素
    
TYPE front();
功能：返回数组中的第一个元素

iterator begin();
const_iterator begin() const;
功能：返回指向第一个元素的迭代器

iterator end();
const_iterator end() const;
功能：返回指向最后一个元素下一个位置的迭代器
注意：迭代器对于vector的用处不大，但对于其他容器，迭代器是唯一的遍历方式
vector<int>::iterator it
for(it=arr.begin(); it!=arr.end(); it++)c++
{
	cout << *it << endl;
}

size_type capacity() const;
功能：获取数组的容量

void clear();
功能：清空数组中所有元素，容量不变，元素数量变为0
 
iterator erase(iterator loc);
功能：删除一个元素
    
iterator erase(iterator start, iterator end);
功能：删除一部分元素
注意：删除元素时必须使用迭代器
    
iterator insert(iterator loc, const TYPE& val);
功能：在某个元素之前插入一个元素，位置以迭代器的形式提供

void insert(iterator loc, size_type num, const TYPE& val);
功能：在某个元素之前插入num个元素，位置以迭代器的形式提供

void insert(iterator loc, input_iterator start, input_iterator end);
功能：在某个元素之前插入一组元素，位置以迭代器的形式提供

size_type max_size() const;
功能：用于计算数组能存储的最大元素数量，因为数组的内存扩张是有限度的 4294907295,由元素类型决定

void pop_back();
功能：删除最后一个元素

void push_back(const TYPE &val);
功能：末尾添加一个元素，当数组内存不够会扩充一倍内存

reverse_iterator rbegin();
功能：返回一个逆向迭代器，它指向最后一个元素

reverse_iterator rend();
功能：返回一个逆向迭代器，它指向第一个元素前一个位置

void reserve(size_type size);
功能：修改数组的容量，只能往大了改

void resize(size_type num, const TYPE& val = TYPE());
功能：修改数组元素数量
可以往小改，相当于删除元素
也可以往大改，相当于增加元素 值是val

void swap(container& from);
功能：交换两个数组的元素

list容器

头文件：list

是一个功能齐全的双向链表

运算符函数：

= = !=
< > < >=

构造函数：

list();
list(const list& c);
list(size_type num, const TYPE& val = TYPE());
list(input_iterator start, input_iterator end);

常用的成员函数：

void assign(size_type num, const TYPE& val);
功能：向链表中插入num个元素，并赋值为val

void assign(input_iterator start, input_iterator end);
功能：向链表中插入一组数据
 
iterator begin();
const_iterator begin() const;
功能：返回一个正向迭代器，指向链表中的第一个元素。

iterator end();
const_iterator end() const;
功能：返回一个正向迭代器，指向链表中的最后一个元素下一个位置。

TYPE& back();
const TYPE& back() const;
功能：返回链表中最后一个元素

TYPE& front();
const TYPE& front() const;
功能：返回链表中第一个元素

iterator erase( iterator loc );
功能：删除链表中的某个位置元素，位置以迭代器方式提供

iterator erase( iterator start, iterator end );
功能：删除链表中的某个范围的元素，范围以迭代器方式提供

iterator insert( iterator loc, const TYPE& val );
功能：向链表中的指定位置插入一个val元素，位置以迭代器方式提供

void insert( iterator loc, size_type num, const TYPE& val );
功能：向链表中的指定位置插入num个val元素，位置以迭代器方式提供

template<TYPE> void insert( iterator loc, input_iterator start,
input_iterator end );
功能：向链表中的指定位置插入一组数据，位置以迭代器方式提供

size_type max_size() const;
功能：获取链表的最大长度

void merge( list &lst );
void merge( list &lst, BinPred compfunction );
功能：合并两个链表，结果为有序链表，如果两个链表是有序，结果依然有有序，lst链表则删除所有元素。
注意：如果链表中的元素不支持<运算符，则需要提供比较函数。

void pop_back();
功能：尾删除

void pop_front();
功能：头删除
    
void push_back( const TYPE& val );
功能：尾添加

void push_front( const TYPE& val );
功能：头添加

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
功能：返回一个逆向迭代器，指向最后一个元素

reverse_iterator rend();
const_reverse_iterator rend() const;
功能：返回一个逆向迭代器，指向第一个元素的前一个位置

void remove( const TYPE &val );
功能：删除链表中所有等于val的元素

void remove_if( UnPred pr );
功能：删除符合条件的元素
pr：
    bool if_func(const TYPE& val)
    {
         return left < val && val < right; 
    }

size_type size() const;
功能：获取链表元素的数量

void sort();
功能：对当前链表进行排序，需要元素支持 < 运算符

void sort( BinPred p );
功能：对当前链表进行排序，元素不支持 < 运算符，需要调用者提供比较函数。
BinPred:
        bool cmp(T a,T b)
        {
            return a<b;
        }

void splice( iterator pos, list& lst );
功能：把链表lst合并到当前链表的指定位置，位置以迭代器方式提供，lst链表则删除所有元素。

void splice( iterator pos, list& lst, iterator del );
功能：把链表lst指定位置的元素合并到当前链表的指定位置，lst中的del位置元素会被删除。

void splice( iterator pos, list& lst, iterator start, iterator end );
功能：把链表lst指定范围的元素合并到当前链表的指定位置，lst中的[start,end)范围的元素会被删除。

void swap( container& from );
功能：交换两个链表

void unique();
功能：删除重复的元素

void unique( BinPred pr );
功能：删除符合条件的重复元素

deque容器：

​ 头文件：#include < deque>

​ 双端队列容器，依靠采用队列的管理规则只能两端进出数据，与普通队列不同的是，它的两端都可以进出

​ 其实就是在向量的基础上增加了两端管理的功能。

构造函数：

deque( size_type size );
功能：创建一个大小为size的双向队列 

deque( size_type num, const TYPE &val );
功能：创建一个双向对象并放置num个值为val的元素

deque( input_iterator start, input_iterator end );
功能：使用一组数据构造一个双向队列

支持的运算符：

[] 既可以访问元素也可以赋值
=、==、!=、<、>、<=、>= 与链表、数组的比较无则相同

常用成员函数：

void assign( input_iterator start, input_iterator end);
功能：使用一组数据给双向队列赋值

void assign( Size num, const TYPE &val );
功能：给队列中的前n个元素赋值为val，并删除后面的元素

TYPE& at( size_type loc );
const TYPE& at( size_type loc ) const;
功能：访问队列中的元素，与[]运算符的功能一样，当下标越界时，at会抛出异常，而[]会可能会产生段错误、脏数据、一切正常。

TYPE& back();
const TYPE& back() const;
功能：获取队尾元素

TYPE& front();
const TYPE& front() const;
功能：获取队头

iterator begin();
const_iterator begin() const;
功能：返回一个正常迭代器，指向第一个元素
iterator end();
const_iterator end() const;
功能：返回一个正常迭代器，指向最后一个元素的下一个位置

void clear();
功能：清空所有元素

bool empty() const;
功能：判断队列是否为空

iterator erase( iterator loc );
功能：删除一个元素
iterator erase( iterator start, iterator end );
功能：删除一个范围的元素

iterator insert( iterator loc, const TYPE& val );
功能：在指定的位置插入一个val元素

void insert( iterator loc, size_type num, const TYPE& val );
功能：在指定的位置插入num个值为val的元素

template<TYPE> void insert( iterator loc, input_iterator start,
input_iterator end );
功能：在指定的位置插入一组元素
size_type max_size() const;
功能：计算出能存储的最多元素数量，原理与vector一样

void pop_back();
功能：从队尾弹出一个元素
void pop_front();
功能：从队头弹出一个元素

void push_back( const TYPE& val );
功能：从队尾入队
void push_front( const TYPE& val );
功能：从队头入队

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
功能：返回一个逆向迭代器，指向最后一个元素

reverse_iterator rend();
const_reverse_iterator rend() const;
功能：返回一个逆向迭代器，指向第一个元素的前一个位置

void resize( size_type size, TYPE val );
功能：修改队列的元素数量
    可以往大了改，相当增加元素 值是val
    也可以往小了改，相当于删除元素

size_type size() const;
功能：获取队列元素的数量

void swap( container& from );
功能：交换两个队列中的元素

priority_queue容器:

​ 头文件：#include < queue>
​ 优先队列，该队列会对入队的数据进行排序，元素越大越先出队。
​ 注意：存储的元素应支持<运算符。

bool empty() const;
功能：判断队列是否为空

void pop();
功能：出队，按排序后的顺序，大的元素优先出队

void push( const TYPE& val );
功能：入队，入队后的元素会自动进行排序

size_type size() const;
功能：获取队列中元素的数量

TYPE& top();
功能：获取队头元素，队列中最大的元素

set容器：

​ 头文件：#include < set>
​ 集合容器，特点是元素不能重复，会对元素自动排序，因此它存储的元素必须支持<运算符，只能使用迭代器遍历。

构造函数：

只有无参构造和拷贝构造。

支持的运算符：与list容器一样。

成员函数：

iterator begin();
const_iterator begin() const;
功能：返回一个正常迭代器，指向第一个元素

iterator end();
const_iterator end() const;
功能：返回一个正常迭代器，指向最后一个元素的下一个位置

void clear();
功能：清空所有元素

bool empty() const;
功能：判断队列是否为空

iterator erase( iterator loc );
功能：删除一个元素
iterator erase( iterator start, iterator end );
功能：删除一个范围的元素

size_type count( const key_type& key );
功能：获取集合中key元素的数量，结果只能是0或1，可用于判断key是否存在，在此容器中无意义。

iterator find( const key_type& key );
功能：查找在集合中查找值为key的元素，并返回指向该元素的迭代器，如果集合中没有key则返回end()的值。

pair<iterator, iterator> equal_range( const key_type& key );
功能：查找集合中值为key的元素，并返回一个迭代器范围[start,end)，在此容器无意义。

void insert( input_iterator start, input_iterator end );
功能：向集合中添加一组元素
pair<iterator,bool> insert( const TYPE& val );
功能：向集合中插入一组元素

key_compare key_comp() const;
功能：返回一个用于比较元素的函数对象。
bool cmp(T& a,T& b)
{
    return !(a<b) && !(b<a);
}

value_compare value_comp() const;
功能：在该容器中它与key_comp的功能一模一样。

iterator lower_bound( const key_type& key );
功能：返回一个大于等于key值的元素的迭代器(最小的)
iterator upper_bound( const key_type& key );
功能：返回一个小于等于key值的元素的迭代器(最大的)

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
功能：返回一个逆向迭代器，指向最后一个元素
reverse_iterator rend();
const_reverse_iterator rend() const;
功能：返回一个逆向迭代器，指向第一个元素的前一个位置

size_type max_size() const;
功能：计算出能存储的最多元素数量，原理与vector一样

void swap( container& from );
功能：交换两个集合中的元素

multiset容器：

​ 头文件：#include < set>
​ 多重集合容器，特点是元素可以重复，会对元素自动排序，因此它存储的元素必须支持<运算符，只能使用迭代器遍历。

size_type count( const key_type& key );
功能：计算值为key的元素的数量，此该容器变的有意义。

pair<iterator, iterator> equal_range( const key_type& key );
功能：查找集合中值为key的元素，并返回一个迭代器范围[start,end)，此该容器变的有意义。

map容器

​ 头文件：#include < map>
​ 映射容器，是由key/value组成的元素(字典),要求key不能有重复，会根据key进行排序，所以key必须支持<运算符。

key和value一一对应，可以根据key(相当于下标)访问value，底层采用红黑树存储数据，因此查找效率极高。

构造函数：
map( iterator start, iterator end);
功能：使用一组数据(pair类型)构造映射容器
map( iterator start, iterator end, const key_compare& cmp );
功能：使用一组数据(pair类型)构造映射容器，并提供key的比较函数。
map(const key_compare& cmp);
功能：构造映射容器，并提供key的比较函数。

支持的运算符：
    [] 使用key值作为下标
    既可以用来访问，也可以用来赋值(插入数据)。

iterator insert( iterator i, const TYPE& pair );
功能：在指定的位置插入一对键值

void insert( input_iterator start, input_iterator end );
功能：几映入容器中插入一组数据(pair类型)

pair<iterator,bool> insert( const TYPE& pair );
功能：插入一对键值，并返回插入的结果。