C++的探索路20标准模板库STL之STL的基本概念与容器

Posted 2022-11-26 Guerrouj

Introduction

重用性是C++语言的核心优势，C++的重用性能够体现在两个方面 1，面向对象的继承和多态机制。 2，通过模板实现泛型编程。
STL的全称为Standard Template Library，为一些常用

数据结构的模板

集合。本章内容，可能。。。有点抽象。。。。也有点杂。。。。。但也许就是STL的魅力吧。。。。。。
看一下本章内容 依据内容相关性，本章分为四个部分，本篇内容涉及STL的基本概念以及容器的一些基本内容。

STL中的基本概念

STL有三个基本概念：容器，迭代器和算法

容器（container）

顾名思义：放东西的地方，比如可变长数组、链表等数据结构。 具体定义为：用于存放数据的

类模板

。由于是一个数据结构，需要经常进行大小比较，所以一般需要重载==及<两种运算符。

分类

容器的具体分类为： 顺序容器 关联容器 容器适配器
顺序容器的顺序指的是位置的顺序:什么地方插入元素，元素就在什么地方。该容器为

非排序容器

，包含三种容器： vector(可变长数组) deque（双端队列） 及list（双向链表）。
关联容器则为排序容器， 插入元素时，容器会按照一定的排序规则被放在适当的位置上。关联容器包含集合与映射两类容器，下面又细分为四种容器。 这部分后面会进行介绍，由于关联容器为排序容器，因此在数据查找的时候具备优良的功能。
容器适配器的作用则是继承了顺序容器和关联容器的内容；屏蔽一些功能，突出另外一些功能。内容为栈stack,队列queue,优先级队列priority_queue。

相关成员函数及容器成员函数

见下图

迭代器(iterator)

1，迭代器为存取容器中存放的元素的工具，相当于指针，它的作用相当于

容器和操纵容器的算法之间的一个中介

；迭代器按照定义方式分为4种： 正向迭代器，常量正向迭代器；反向迭代器，常量反向迭代器.
正向迭代器的定义方法为 容器类名::iterator 迭代器名;
反向迭代器的定义方法为 容器类名::reverse_iterator 迭代器名;
2，容器适配器没有迭代器，其自带一些成员函数进行访问。

迭代器用法示例

通过迭代器遍历一个vector容器中的所有元素

#include<iostream>
#include<vector>
using namespace std;

int main()

	vector<int>v;
	for (int n = 0; n < 5; ++n)
		v.push_back(n);
	vector<int>::iterator i;
	for (i = v.begin(); i < v.end(); ++i) 
		cout << *i << " ";
		*i *= 2;
	
	cout << endl;
	for (vector<int>::reverse_iterator j = v.rbegin(); j != v.rend(); ++j)
		cout << *j << " ";
    return 0;

1，程序中定义了一个vector<int>类型的动态数组v,通过push_back()函数进行内容写入，写入内容为0~4 2，通过正向迭代器进行循环输入，v.begin()指向首地址，v.end()指向尾地址，在循环内部首先进行输出，然后再对该位置的值进行翻倍操作，所以，输出 0 1 2 3 4 3，第二个循环调用反向迭代器进行操作，对vector内部元素进行反向输入，注意：此时vector内部成员翻倍了，不是0 1 2 3 4，而是 0 2 4 6 8;并且是反向迭代器操作，因此，输出结果为 8 6 4 2 0

迭代器功能分类

常用迭代器按功能强弱可分为：输入、输出、正向、双向和随机访问5种，书中只介绍了后三种 正向迭代器 支持前后向的自增操作及指针访问，并且两个正向迭代器可以相互赋值。 双向迭代器 具备正向迭代器的所有功能，并且支持自减操作 随机访问迭代器 支持上面所有功能，并且类似于指针，支持+=,-=,[]操作，此外

随机访问迭代器

还支持大小比较操作，这一点是非常重要的。
比如vector和deque支持随机访问迭代器等
由于vector支持的迭代功能多，下面例子就对vector进行分析

int main() 
	vector<int>v(100);
	for (int i = 0; i < v.size(); ++i)
		cout << v[i];
	vector<int>::iterator i;
	for (i = v.begin(); i < v.end(); ++i)
		cout << *i;
	for (i = v.begin(); i != v.end(); ++i)
		cout << *i;
	i = v.begin();
	while (i < v.end()) 
		cout << *i;
		i += 2;
	
	return 0;

联系上面的内容：随机访问迭代器支持大小比较操作，所以可以写成i<v.end()的形式，如果为仅支持双向迭代器的list<int>则将会出现错误，因为list不支持<,>运算

迭代器辅助函数

主要有三个函数模板用于操作迭代器：

1,advance(p,n) 用于迭代器前后移动n个元素

2,distance(p,q) 用于计算两个迭代器之间的距离

3, iter_swap(p,q) 交换两个迭代器p,q指向的值

注意，使用这些辅助函数，需要include头文件<algorithm>

int main() 
	int a[5] =  1,2,3,4,5 ;
	list<int>lst(a, a + 5);
	list<int>::iterator p = lst.begin();
	advance(p, 2);
	cout << "1)" << *p << endl;
	advance(p, -1);
	cout << "2)" << *p << endl;
	list<int>::iterator q = lst.end();
	q--;
	cout << "3)" << distance(p,q) << endl;
	cout << "4)" << *q << endl;
	for (p = lst.begin(); p != lst.end(); ++p) 
		cout << *p << endl;
	
	return 0;

程序解析：

以上程序为迭代器的辅助函数示例

首先用a数组给双向链表对象:lst赋值。

然后正向迭代器list<int>::iterator p指向链表的首地址。

迭代器p首先通过advance函数模板，后向移动2个单位：指向a[2]，即输出3

而后p向后移动一个单位，指向a[1]，输出2

然后定义了迭代器q，指向lst的最后一个元素的后一个位置的迭代器（一定要注意，end()是彻底抄底），然后进行q--,指向最后一个元素a[4]。

此时输出distance(p,q)也就是a[1]->a[4]的距离：3

整体输出：

1) 3

2) 2

3) 3

4) 5

1

2

3

4

5

算法(algorithm)

这个相对就更简单了：运算方式。算法的实质是函数模板，算法通过迭代器来操纵容器中的元素；很多算法操作的说容器的一个区间，因此需要两个参数进行位置确定。
例子：int array[10]就是一个容器, int*为迭代器， sort(array,array+10)中的sort就是算法。 来个find函数模板，find函数模板的原型如下

template<class InIt, class T>
InIt find(InIt first, InIt last, const T&val)

find函数的功能

可以是

： 在迭代器first和last指定的容器区间[first, last)中，按顺序查找和val相等的元素，如果找到，则返回该元素的

迭代器

；如果找不到，返回last。 因此，find判断元素相等是用"=="运算符作比较的，如果[first,last)中存放的为对象，那么应当对“==”适当重载。
另外，上面标注了可以是，而不是其功能就是，因为这种代码完成什么功能，取决于程序员的想象力。 来一个find算法的例子。

int main() 
	int a[10] =  10,20,30,40 ;
	vector<int>v;
	v.push_back(1); v.push_back(2);
	v.push_back(3); v.push_back(4);
	vector<int>::iterator p;
	p = find(v.begin(), v.end(), 3);
	if (p != v.end())
		cout << "1)" << *p << endl;
	p = find(v.begin(), v.end(), 9);
	if (p == v.end())
		cout << "not found" << endl;
	p = find(v.begin() + 1, v.end() - 1, 4);
	cout << "2)" << *p << endl;
	int *pp = find(a, a + 4, 20);
	if (pp == a + 4)
		cout << "not found" << endl;
	else
		cout << "3)" << *pp << endl;
	return 0;

程序定义： 该程序首先定义了一个容量为10的int数组a,并且依次赋值10,20,30,40。 接着定义了一个内部元素类型为int动态数组v，并通过push_back()函数进行赋值。 第三次则定义一个vector<int>类型的迭代器p。 find(): 1，在动态数组v内寻找元素3，如果没有到底，则输出p，因此输出1） 3 2，在动态数组里寻找9，显然不存在，因此应当输出not found 3，在动态数组第二个到最后一个元素中寻找4，显然存在：2) 4 4，在数组a内寻找20，如果到了末尾没找到则not found,但显然是有的，因此输出3) 20

函数对象

函数对象的实质为运算符()的重载，但和前面的运算符重载略有不同，由于()是目数不限的运算符，所以函数对象能允许多个参数的输入。 具体例子如下：

class CAverage 
public:
	double operator()(double a1, double a2, double  a3) 
		return double(a1 + a2 + a3) / 3;
	
;
int main() 
	CAverage a;
	cout << a(2, 3, 4) << endl;
	return 0;

函数对象用法之accumulate算法

template<class T>
void PrintInterval(T first, T last) 
	for (; first != last; ++first)
		cout << *first << " ";
	cout << endl;

int SumSquares(int total, int value) 
	return total + value*value;

template<class T>
class SumPowers 
private:
	int power;
public:
	SumPowers(int p):power(p)
	const T operator()(const T&total, const T&value) 
		T v = value;
		for (int i = 0; i < power - 1; ++i)
			v = v*value;
		return total + v;
	
;

int main() 
	const int SIZE = 10;
	int a1[] =  1,2,3,4,5,6,7,8,9,10 ;
	vector<int>v(a1, a1 + SIZE);
	cout << "1)";
	PrintInterval(v.begin(), v.end());
	int result = accumulate(v.begin(), v.end(), 0, SumSquares);
	cout << "2)平方和：" << result << endl;
	result = accumulate(v.begin(), v.end(), 0, SumPowers<int>(3));
	cout << "3)立方和：" << result << endl;
	return 0;

accumulate算法的基本形式为

template<class InIt, class T, class Pred>
T accumulate(InIt first,InIt last, T init, Pred op)
   for(; first!=last;++first)
   init=op(init,*first);
   return init;

该算法的形参中共包含四个参数，前两个参数为InIt类型的迭代器，第三个参数为起始值，第四个参数为程序员自己需要定义的op。
由于op的调用形式为op(init,*first)，因此op只能为函数指针或者函数对象。 first为指向首元素的指针，在内部实现逐级递增。
比如我们要实现平方和相加的函数，则可以定义一个SumPowers的函数指针如下：

int SumSquares(int init, int value) 
	return init + value*value;

如果我们需要实现N次方的相加，比如给出SumPowers<int>(3)的形式来计算立方和相加，那么应该怎么定义SumPowers类？ SumPowers<int>(3)为一个实例化对象，需要首先定义SumPower

类模板

，类模板的内部包含构造函数，能够进行相应的赋值： 类模板初期定义如下：

template<class T>
class SumPowers 
private:
	int power;
public:
	SumPowers(int p) :power(p) ;
;

接着完善函数功能，回到accumulate的定义形式：需要定义一个函数对象或者函数指针方能完成accumulate的任务。
函数对象的定义方式见运算符重载的方式：

	T operator()(const T &init, const T &value) 
		T val = value;
		for (int i = 0; i < power-1; ++i)
			val = val*value;
		return init +  val;
	

函数对象应用实例： sort算法

Basic knowledges

STL中排序模板能将区间从小到大排序，sort有两种版本 一版本：

template<class _RandIt>
void sort(_RandIt first,_RandIt last)

该函数模板可以将区间为[first,last)的元素进行从小到大排序 要求： 1，first,last应该为随机访问迭代器 2，元素大小比较通过<来进行（因此，必须重载<运算符）
二版本

template<class _RandIt,class Pred>
void sort(_RandIt first, _RandIt last,Pred op)

该函数模板比较大小是通过函数对象op进行实现的，在op内部定义了元素大小比较的规则。

using namespace std;
template<class T>
void PrintInterval(T first, T last) 
	for (; first != last; ++first)
		cout << *first << " ";
	cout << endl;

class A 
public:
	int v;
	A(int n):v(n)
;
bool operator<(const A&a1, const A&a2) 
	return a1.v < a2.v;

bool GreatA(const A&a1, const A&a2) 
	return a1.v > a2.v;

struct LessA 
	bool operator()(const A&a1, const A&a2) 
		return (a1.v % 10) < (a2.v % 10);
	
;
ostream &operator<<(ostream&o, const A&a) 
	o << a.v;
	return o;

int main() 
	int a1[4] =  5,2,4,1 ;
	A a2[5] =  13,12,84,9,13 ;
	sort(a1, a1 + 4);
	cout << "1)"; PrintInterval(a1, a1 + 4);
	sort(a2, a2 + 5);
	cout << "2)"; PrintInterval(a2, a2 + 5);
	sort(a2, a2 + 5,GreatA);
	cout << "3)"; PrintInterval(a2, a2 + 5);
	sort(a2, a2 + 5, LessA());
	cout << "4)"; PrintInterval(a2, a2 + 5);
	return 0;

完整程序如上述所示，先从主程序进行分析： 主程序共定义两个对象，一个对象为整形数组a1，另个对象为A类型的数组a2；所以第一步应该定义A类。

class A
public:
	int v;
	A(int n):v(n)
;

在sort排序方面，前两个调用了I类sort函数，而A类的大小比较形式没有给出；第二步应当重载<运算符进行大小比较。

bool operator<(A &a1,A &a2) 
	return a1.num < a2.num;

除此之外，还需要对排序后的数组进行打印操作，而打印又不限定于整形；故，第三步应为定义函数模板PrintInterval

template<class T>
void PrintInterval(T first, T last) 
	for (; first != last; ++first)
		cout << *first << " ";
	cout << endl;

直接打印A对象显然不可行，所以需要重载<<运算符：

ostream& operator << (ostream&o,const A&a) 
	o << a.num;
	return o;

进入到第三次排序，需要定义个GreatA进行从小到大的排序，这个也简单：定义bool类型的反向比较就行：

bool GreatA(A&a1,A&a2) 
	return a1.num > a2.num;

最后一次排序调用了LessA()使得末尾从小到大排列，而这个时候是LessA()，而不是LessA，说明定义了一个函数对象。 在这里就搞个结构体吧：

struct LessA 
	bool operator()(const A&a1, const A&a2) 
		return (a1.num % 10) < (a2.num % 10);
	
;

本章回顾

本部分的内容有点多和杂，由于STL是建立在函数模板的基础上的一种神器，并且其对语法的要求不高，关键是多加练习，所以在这里就略过了一些内容。 STL总共有三个重要的概念：容器，迭代器和算法。 容器就是未定数据类型的家，迭代器相当于指针，算法则是告诉我们这些东西是怎么去算的。
容器依据其性质可以分为顺序容器，关联容器和容器适配器。 顺序容器是指插入顺序，而不是大小顺序，所以顺序容器为非排序容器，其中典型的容器有vector,deque和list。 关联容器则为排序容器。 容器适配器则在顺序容器和关联容器的基础上屏蔽了一些性质，突出了一些性质。
函数对象实质上就是()运算符的重载，区别于前面较少参数的运算符重载，()没有参数个数的要求，可以重载携带多个形参，在STL中()的重载则发挥了极大的作用。

到这里，C++探索路的基本系列的学习部分就结束了，接下来的几课，将为c++的练习题。