C++学习：STL

简介

    STL(Standard Template Library，标准模板库)，由惠普实验室开发，主要出现在C++中。STL在广义上分为三类：algorithm(算法)、container(容器)和iterator(迭代器)，容器和算法通过迭代器进行连接。在惠普实验室最初发行版本中STL被组织成48个头文件，而在C++标准中，STL被组织为13个头文件：<iterator>、<functional>、<vector>、<deque>、<list>、<queue>、<stack>、<set>、<map>、<algorithm>、<numeric>、<memory>和<utility>。

容器

    STL中的容器分为两大类：序列式（元素有固定位置，元素位置和插入顺序有关，和元素本身无关）和关联式。

    其中序列式容器包含vector、deque、list、stack和queue，关联式容器包含set、multiset、map和multimap。

vector

    vector(向量)，将元素放置在一个动态数组，支持随机存取元素，特点：在尾部插入删除元素快，在中间和头部部插入删除元素较慢。

    使用：

1、头部包含头文件

    在头文件处包含vector头文件：

#include <vector>

2、构造vector对象

    在使用处构造vector对象，语法如下：

#include <vector>


vector<T> name;

    其中name就是我们vector对象的名字，T是vector容器中想要存放元素的类型，常见类型有int、float、string等。

3、成员函数

对vector成员函数的学习来源vector成员函数

        1、vector()

创建一个向量。

        2、vector(int nSize)

创建一个大小为nSize的vector。

        3、vector(int nSize, const t& t)

创建一个大小为nSize，均值为t的vector。

        4、vector(const vector&)

复制构造函数。

        5、vector(begin, end)

复制另一个数组区间[begin, end)的元素到到vector中。

        6、void push_back(const T& x)

尾部添加x。

        7、iterator insert(iterator it, const T& x)

在it指向的元素前增加元素x。

        8、iterator insert(iterator it, int n, const T& x)

在it指向的元素之前添加n个元素，值为x。

        9、iterator insert(iterator it, const_iterator first, const_iterator last)

在it指向的元素之前添加类型相同的区间在[first, last)之间的元素。

        10、iterator erase(iterator it)

删除it指向的元素。

        11、iterator erase(iterator first, iterator last)

删除区间[first, last)的元素。

        12、void pop_back()

删除向量最后一个元素。

        13、void clear()

清空所有元素。

        14、reference at(int pos)

返回pos元素的引用。

        15、reference front()

返回首元素的引用。

        16、reference back()

返回尾元素的引用。

        17、iterator begin()

返回向量头指针，指向第一个元素。

        18、iterator end()

返回向量尾指针，指向向量最后一个元素的下一个位置。

        19、reverse_iterator rbegin()

反向迭代器，指向最后一个元素。

        20、reverse_iterator rend()

反向迭代器，指向第一个元素之前的位置。

        21、bool empty() const

判断向量是否为空，空代表向量中没有元素。

        22、int size() const

返回向量中元素个数。

        23、int capacity() const

返回当前向量中所能容纳的最大元素值。        

        24、int max_size() const

返回最大可允许的vector元素数量值。

        25、void swap(vector&)

交换两个同类型向量的数据。

        26、void assign(int n, const T& x)

设置元素个数为n，每个的值都为x。

        27、void assign(const_iterator first, const_iterator last)

将区间[first, end)的元素设置成当前向量元素。

    deque

学习来源：双端队列

deque(双端队列)，在队列两端可以进行扩展或者收缩的序列化容器。同时，存储数据的空间是一段一段等长连续空间构成，各段空间并不一定连续，可能位于内存不同区域，使用一个中控器(指针数组)map来指向这些一段一段的空间，如果当前段空间用完，则添加一个新的空间并将其链接在头部或者尾部，特殊的存储结构导致deque的迭代器随机访问的速度低于vector。

     1、头文件

#include <deque>

    2、构造deque对象

#include <deque>


deque<T> name;

其中T是deque对象的数据类型，name是队列的名字。

    3、成员函数

定义deque对象：

#include <deque>


deque<T> name1;           //创建一个空队列name1，T为队列元素类型，执行默认初始化
deque<T> name2(name1);    //name2中包含name1中所有的元素
deque<T> name2 = name1;   //等价于name2(name1)
deque<T> name3(n, value); //队列大小为n，n个元素的值都为value
deque<T> name4(n);        //包含n个元素，重复执行初始化
deque<T> name5{1, 2, 3.....};//name5包含了花括号中所有的元素
deque<T> name6 = {1, 2, 3, 4....};//等价于name5   

迭代器函数：

#include <deque>


deque<int> v1{1, 2, 3, 4};
v1.begin();                   //指向v1首元素的迭代器
v1.end();                     //指向v1尾元素的下一个位置的迭代器
v1.rbegin();       //指向v1尾元素的反向迭代器，rbegin()指向尾元素，rbegin()-1指向倒数第二个元素
v1.rend();         //指向v1头元素的前一个位置的迭代器，rend()-1指向第一个元素
v1.cbegin();       //指向v1首元素的迭代器，增加了const属性，不能用于修改元素
v1.cend();         //指向v1尾元素的下一个位置，增加const属性，不能用于修改元素
v1.crbegin(); //指向v1尾元素的反向迭代器，与rbegin()相同，但是增加了const属性，不能用于修改元素
v1.crend();   //指向v1头元素的前一个位置的反向迭代器，和rend()相同，增加了const属性不能修改元素

其他函数：

#include <deque>


deque<T> v1{1, 2, 3, 4};
v1.size();               //返回v1中的元素个数。
v1.max_size();           //返回v1最多能容纳元素的个数。
v1.resize(n);            //改变v1的size，改为n。
v1.empty();              //判断v1是否为空。
v1.shrink_to_fit();      //减少v1容量，用以适应元素个数。
v1.at(index);            //index为索引，但必须合法。
v1.front();              //返回v1的第一个元素。
v1.back();               //返回v1的最后一个元素。
v1.assign();             //用新的元素替换v1中的旧元素。
v1.push_back();          //v1尾部添加一个元素。
v1.push_front();         //在v1头部添加一个元素。
v1.pop_back();           //移除v1尾部的一个元素。
v1.pop_front();          //删除v1头部的一个元素。
v1.insert();             //添加元素。
v1.erase();              //删除元素。
v1.clear();              //清空元素。
v1.swap();               //交换元素。

    list

学习来源list

list是序列化容器，可以在list任何位置进行插入或删除元素，时间复杂度都是O(1)，并可以在两个方向进行迭代。list使用双向链表实现，通过next、prev指针链接成顺序表，但是list不能通过位置直接访问元素，要访问元素只能迭代过去，时间复杂度为线性。因为需要存储next、prev等来保持元素关联，致使存储密度较低。

    1、头文件

#include <list>

    2、构造list对象

#include <list>


list<T> list1;      //默认构造函数，构造一个空容器。
list<T> list2(size_type count, const T& value); //容器大小为count，值均为value。

这里只是对构造list对象的函数列举了两个，其他的构造函数大家可以自己去详查。

    3、成员函数

#include <list>


list<int> list1{1, 2, 3, 4};
list1.begin();          //返回指向list首元素的迭代器
list1.end();            //返回指向lsit尾元素的下一个元素的位置
lsit1.empty();          //判断容器是否为空，如果容器为空，则list1.begin() == list1.end()
list1.clear();          //清空所有元素
list1.insert();         //插入元素

list的成员函数很多，这里只列出一部分，剩下的感兴趣的读者可以自己去详细了解。

    stack

学习来源：stack

stack(堆栈)，一个先进先出的线性数据结构。这里对栈元素的插入删除操作只能在尾结点进行，而查看也只能查看尾结点。

    头文件

#include <stack>

    构造stack对象

#include <stack>


stack<T> stk1;     //默认构造形式
stack<T> stk2(const stack &stk1);  //拷贝构造函数

    成员函数

#include <stack>


stack<int> stk;
stk.size();        //返回栈中元素的个数
stk.top();         //返回栈顶元素
stk.pop();         //返回栈顶元素并将其从栈中删除
stk.push(e);       //向栈中添加元素e
stk.empty();       //判断栈是否为空

还有其他许多成员函数，这里不浪费篇幅一一列举，读者可自行查找了解。

    queue

学习来源：queue，queue1。队列，一种先进先出的数据结构，共有两个出口，可以从队头出元素队尾入元素，因此队列不允许遍历。

        头文件

#include <queue>

        构造queue对象

#include <queue>


queue<type> q1;

其中q1为队列名字，type为队列中元素的类型，可以是常见类型，也可以自己定义。

        成员函数

#include <queue>


queue<int> q1;


q1.back();     //返回队列最后一个元素
q1.empty();    //判断队列是否为空
q1.front();    //返回队列第一个元素
q1.pop();      //删除队列的第一个元素
q1.push();     //在队尾加入一个元素
q1.size();     //返回队列大小

    set

有序集合，关联容器的一种，基于红黑树实现，对于元素的查找、删除、插入时间复杂度都是O(log n)。其中元素不可重复，具有唯一性。学习来源：set

        头文件

#include <set>

        构造set对象

#include <set>


set<type> set1;

        成员函数

#include <set>


set<int> set1;
set<int> set2;


set1.insert(1);   //向set1中放入元素1
set1.erase(1);    //删除set1中的元素1
set1.empty();     //判断集合是否为空
set1.size();      //返回set1的大小
set1.count(1);    //统计1在集合中出现次数，返回结果只能是1或0,1表示集合中存在
set1.swap(set2);  //将set1中元素与set2中的元素交换

    multiset

    map

    multimap

    算法

    迭代器

    未完待补充，要睡觉了......