标准模板库STL学习总结

标准模板库就是类与函数模板的大集合。STL共有6种组件：容器，容器适配器，迭代器，算法，函数对象和函数适配器。

1、容器：

容器是用来存储和组织其他对象的对象。STL容器类的模板在标准头文件中定义。主要如下所示

①序列容器

基本的序列容器是上面图中的前三类：

关于三者的优缺点主要是：

A:vector<T>矢量容器：可以随机访问容器的内容，在序列末尾添加或删除对象，但是因为是从尾部删除，过程非常慢，因为必须移动插入或删除点后面的所有对象。

矢量容器的操作：（自己以前有个表，贴出来大家看看）

其中的capacity表示容量，size是当前数据个数。矢量容器如果用户添加一个元素时容量已满，那么就增加当前容量的一半的内存，比如现在是500了，用户添加进第501个，那么他会再开拓250个，总共就750个了。所以矢量容器当你添加数据量很大的时候，需要注意这一点哦。。。

如果想用迭代器访问元素是比较简单的，使用迭代器输出元素的循环类似如下：

vector<int>::iterator表示矢量容器vector<int>的迭代器。。。

vector<int>::iterator表示矢量容器vector<int>的迭代器。。。

for(vector<int>::iterator iter = number.begin(); iter<number.end(); iter++)//这里的iterator iter算是一个指针了
     cout << " " << *iter;

for(vector<int>::iterator iter = number.begin(); iter<number.end(); iter++)//这里的iterator iter算是一个指针了
     cout << " " << *iter;

当然也可以用我们自己的方法，但是感觉用上面的更好一些。

for(vector<int>::size_type i=0; i<number.size(); i++)
    cout << " " << number[i]

for(vector<int>::size_type i=0; i<number.size(); i++)
    cout << " " << number[i]

排序矢量元素：

对矢量元素的排序可以使用<algorithm>头文件中定义的sort()函数模板来对一个矢量容器进行排序。但是有几点要求需要注意

1. sort()函数模板用<运算符来排列元素的顺序，所以容器中对象必须可以进行<运算，如果是基本类型，可以直接调用sort()，如果是自定义对象，必须对<进行运算符重载
2. 两个迭代器的指向必须是序列的第一个对象和最后一个对象的下一个位置。比如：sort(people.begin(), people.end());//这里两个参数就是迭代器的意思了

B:deque<T>容器：非常类似vector<T>，且支持相同的操作，但是它还可以在序列开头添加和删除。

deque<T>双端队列容器与矢量容器基本类似，具有相同的函数成员，但是有点不同的是它支持从两端插入和删除数据，所以就有了两个函数：push_front和pop_front。并且有两个迭代器变量

<span style="font-size: 18px;">#include <deque>
deque<int> data;//创建双端队列容器对象
deque<int>::iterator iter;//书序迭代器
deque<int>::reverse_iterator riter;//逆序迭代器。
//iter和riter是不同的类型</span>

#include <deque>
deque<int> data;//创建双端队列容器对象
deque<int>::iterator iter;//书序迭代器
deque<int>::reverse_iterator riter;//逆序迭代器。
//iter和riter是不同的类型

C:list<T>容器是双向链表，因此可以有效的在任何位置添加和删除。列表的缺点是不能随机访问内容，要想访问内容必须在列表的内部从头开始便利内容，或者从尾部开始。

②关联容器

map<K, T>映射容器:K表示键，T表示对象，根据特定的键映射到对象，可以进行快速的检索。

有关它的创建以及查找的操作作如下总结

//创建映射容器
map<person, string> phonebook;

//创建要存储的对象
pair<person, string> entry = pair<person, string>(person("mel",
"Gibson"), "213 345 567");

//插入对象
phonebook.insert(entry);//只要映射中没有相同的键，就可以插入entry

//访问对象
string number = phonebook[person("mel",
"Gibson")];//如果这个键不存在，会默认将这个键插入

//如果不想在找不到的时候插入，可以先查找然后再检索
person key = person("mel", "Gibson");
map<person, string>::iterator iter = phonebook.find(key);//创建迭代器，就认为是指针就好了

if(iter != phonebook.end())
    string  number = iter->second;

//创建映射容器
map<person, string> phonebook;

//创建要存储的对象
pair<person, string> entry = pair<person, string>(person("mel", "Gibson"), "213 345 567");

//插入对象
phonebook.insert(entry);//只要映射中没有相同的键，就可以插入entry

//访问对象
string number = phonebook[person("mel", "Gibson")];//如果这个键不存在，会默认将这个键插入

//如果不想在找不到的时候插入，可以先查找然后再检索
person key = person("mel", "Gibson");
map<person, string>::iterator iter = phonebook.find(key);//创建迭代器，就认为是指针就好了

if(iter != phonebook.end())
	string	number = iter->second;

2、容器适配器：

容器适配器是包装了现有的STL容器类的模板类，提供了一个不同的、通常更有限制性的功能。具体如下所示

A:queue<T>队列容器：通过适配器实现先进先出的存储机制。我们只能向队列的末尾添加或从开头删除元素。push_back() pop_front()

代码：queue<string, list<string> > names;(这就是定义的一个适配器)是基于列表创建队列的。适配器模板的第二个类型形参指定要使用的底层序列容器，主要的操作如下

B:priority_queue<T>优先级队列容器：是一个队列，它的顶部总是具有最大或最高优先级。优先级队列容器与队列容器一个不同点是优先级队列容器不能访问队列后端的元素。

默认情况下，优先级队列适配器类使用的是矢量容器vector<T>，当然可以选择指定不同的序列容器作为基础，并选择一个备用函数对象来确定元素的优先级代码如下

priority_queue<int, deque<int>, greate<int>> numbers;

priority_queue<int, deque<int>, greate<int>> numbers;

C:stack<T>堆栈容器：其适配器模板在<stack>头文件中定义，默认情况下基于deque<T>容器实现向下推栈，即后进先出机制。只能访问最近刚刚进去的对象

<span style="font-size: 18px;">//定义容器
stack<person> people;
//基于列表来定义堆栈
stack<string, list<string>> names;</span>

//定义容器
stack<person> people;
//基于列表来定义堆栈
stack<string, list<string>> names;

基本操作如下：

3、迭代器：

具体它的意思还没怎么看明白，书上介绍迭代器的行为与指针类似，这里做个标记，看看后面的例子再给出具体的解释

具体分为三个部分：输入流迭代器、插入迭代器和输出流迭代器。

、

看这一章的内容看的我有点抑郁了都，摘段课本介绍的内容，还是可以帮助理解的

<iterator>头文件中定义了迭代器的几个模板：①流迭代器作为指向输入或输出流的指针，他们可以用来在流和任何使用迭代器或目的地之间传输数据。②插入迭代器可以将数据传输给一个基本序列容器。头文件中定义了两个流迭代器模板：istream_iterator<T>用于输入流，ostream_iterator<T>用于输出流。T表示从流中提取数据或写到流中的对象的类型。头文件还定义了三个插入模板：insert<T>, back_insert<T>和front_inset<T>。其中T也是指代序列容器中数据的类型。

输入流迭代器用下面的程序来说明下，可见具体注释

#include <iostream>
#include <vector>
#include <numeric>
#include <sstream>

using namespace std;

int main()
{
    //定义矢量容器
    vector<int> numbers;
    cout << "请输入整数值，以字母结束:";

    //定义输入流迭代器。注意两个不同
    //1、numberInput(cin)是指定迭代器指向流cin
    //2、numbersEnd没有指定，是默认的，默认构造了一个end_of_stream的迭代器，它等价于调用end()
    istream_iterator<int> numbersInput(cin), numbersEnd;

    //用户输入，直到输入的不是int类型或者终止时结束。
    while(numbersInput != numbersEnd)
        numbers.push_back(*numbersInput++);

    cout << "打印输出：" << numbers.at(3) << endl;


    //如何指定输入流呢？

    //确定字符串
    string data("2.1 3.6 36.5 26 34 25 2.9 63.8");

    //指定data为输入流input。需要头文件<sstream>
    istringstream input(data);

    //定义迭代器
    istream_iterator<double> begin(input), end;

    //计算数值和。
    //acculumate为头文件<numeric>下定义的函数。
    //第一个参数是开始迭代器，第二个是终止迭代器(最后一个值的下一个)。第三个是和的初值，注意必须用0.0，用它确定数据类型是double
    cout << "打印数据的总和：" << accumulate(begin, end, 0.0) << endl;
}

#include <iostream>  
#include <vector>
#include <numeric>
#include <sstream>

using namespace std;  
 
int main()
{
	//定义矢量容器
	vector<int> numbers;
	cout << "请输入整数值，以字母结束:";

	//定义输入流迭代器。注意两个不同
	//1、numberInput(cin)是指定迭代器指向流cin
	//2、numbersEnd没有指定，是默认的，默认构造了一个end_of_stream的迭代器，它等价于调用end()
	istream_iterator<int> numbersInput(cin), numbersEnd;

	//用户输入，直到输入的不是int类型或者终止时结束。	
	while(numbersInput != numbersEnd)
		numbers.push_back(*numbersInput++);

	cout << "打印输出：" << numbers.at(3) << endl;


	//如何指定输入流呢？
	
	//确定字符串
	string data("2.1 3.6 36.5 26 34 25 2.9 63.8");

	//指定data为输入流input。需要头文件<sstream>
	istringstream input(data);

	//定义迭代器
	istream_iterator<double> begin(input), end;

	//计算数值和。
	//acculumate为头文件<numeric>下定义的函数。
	//第一个参数是开始迭代器，第二个是终止迭代器(最后一个值的下一个)。第三个是和的初值，注意必须用0.0，用它确定数据类型是double
	cout << "打印数据的总和：" << accumulate(begin, end, 0.0) << endl;
}

输出结果：

耽误时间太多。以后再写吧

4、算法：

算法是操作迭代器提供的一组对象的STL函数模板，对对象的一个操作，可以与前面的容器迭代器结合起来看。如下图介绍

5、函数对象：

函数对象是重载()运算符的类类型的对象。就是实现operator()()函数。

函数对象模板在<functional>头文件中定义，必要时我们也可以定义自己的函数对象。做个标记，等有具体实例来进行进一步的解释。

6、函数适配器：

函数适配器是允许合并函数对象以产生一个更复杂的函数对象的函数模板。