详解c++---stack和dequeue的介绍

stack介绍

首先stack是一个类这个类是专门用来存数据，并且这个类是一个模板类，所以我们可以使用这个stack来存储各种各样的数据，但是这个类在存储数据的时候得遵循LIFO规则也就是后进先出原则：后进入stack的数据会先出stack，我们把最后进入stack对象的数据称为栈顶元素，把最先进入stack对象的数据称为栈底元素，下面是这个类的英文介绍：

stack的定义

我们来看看stack的构造函数：

库中的stack函数只提供了一种形式，并且这种形式的参数只有一个还提供了缺省值，那么我们在使用这个类的时候就不要管这个参数直接使用缺省值即可，比如下面的代码：

#include<iostream>
#include<stack>
using namespace std;
int main()
{
	stack<int> s1;
	return 0;
}

这样我们就创建了一个空类。

stack的数据插入

在stack中插入数据只能用到push函数：

这个函数有一个参数，并且该参数是value_type类型，那么这个类型的意思是:模板中第一个参数的类型

也就是stack在显示初始化的时候我们给的那个类型，那么该函数的使用代码如下：

#include<iostream>
#include<stack>
using namespace std;
int main()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	return 0;
}

我们可以通过调试看到这里的s1中确实有数据1 2 3 4 ：

stack中数据的个数

这个函数就是显示stack对象中含有数据的个数

比如下面的代码：

int main()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	size_t _size = s1.size();
	cout << "对象中还有的个数为：" << _size << endl;
	return 0;
}

这段代码的运行结果为：

stack数据删除

在stack当中不存在头删尾删和任意位置的删除，只有一个pop函数来删除数据最后进入stack对象的数据，也就是栈顶元素：

比如说下面的代码：

int main()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	size_t _size = s1.size();
	cout << "对象中还有的个数为：" << _size << endl;
	s1.pop();
	return 0;
}

我们通过调试可以看到在pop函数执行之前对象s1中的内容为：

当我们执行完这里的pop函数之后，由于元素4是最后一个进入stack对象的，所以它是栈顶元素，那么在执行完pop函数之后该元素就会被删除，我们来看看调试的结果：

那么这就是pop函数的作用。

stack中数据的查看

在stack当中没有迭代器，范围for和操作符[ ]重载这些功能，因为stack遵守后进先出的LIFO规则，所以我们这里只能通过top函数来查看stack对象中的栈顶元素的内容，

当我们想看栈顶的后一个元素的时候，就只能将栈顶的元素删除再调用top函数来进行查看，比如说下面的代码：

int main()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	size_t _size = s1.size();
	cout << "对象中还有的个数为：" << _size << endl;
	cout << "对象中栈顶的元素为：" << s1.top() << endl;
	s1.pop();
	_size = s1.size();
	cout << "对象中还有的个数为：" << _size << endl;
	cout << "现在栈顶的元素为：" << s1.top() << endl;
	return 0;
}

这段代码的运行结果如下：

并且我们还可以通过top函数来修改栈顶元素的内容，比如说下面的代码：

int main()
{
	stack<int>s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	cout << "修改前栈顶的元素为：" << s1.top() << endl;
	s1.top() = 10;
	cout << "修改后栈顶的元素为：" << s1.top() << endl;
}

这段代码的运行结果如下：

判断stack对象是否为空

当我们想看看stack对象是否为空的时候就可以用到empty函数，这个函数的功能就是检查对象的数据是否为空，如果为空的话这个函数就会返回true，如果不为空的话这个函数就会返回flase，该函数的介绍如下：

这里就不用演示了。

stack对象的数据交换

stack也提供了，swap函数其作用就是将两个stack对象的数据进行交换，该函数的介绍如下：

我们可以看看下面的代码：

int main()
{
	stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	stack<int> s2;
	s2.push(5);
	s2.push(6);
	s2.push(7);
	s2.push(8);
	s1.swap(s2);
	return 0;
}

在执行swap函数之前两个对象的内容如下：

执行完swap函数之后两个对象的内容为：

那么以上就是stack库中的所有基本内容。

queue的介绍

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。
4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

queue的定义

这个对象的构造函数也只有一个参数，并且这个参数也是提供了缺省参数，我们使用的时候可以不用管，我们使用的时候直接创建一个空队列就行：

#include<iostream>
#include<queue>
using namespace std;
int main()
{
	queue<int> q1;
	return 0;
}

queue的数据插入

通过这个函数，我们可以往指定队列对象中插入数据，那么这里的参数类型得和队列的数据相同，我们可以看卡下面的代码：

#include<iostream>
#include<queue>
using namespace std;
int main()
{
	queue<int> q1;
	q1.push(1);
	q1.push(2);
	q1.push(3);
	q1.push(4);
	return 0;
}

我们创建队列的时候显示初始化为int类型，那么我们使用push函数的时候也得传递int类型的数据，那么我们这里就可以通过调试来看到这个对象的中内容：

front

这个函数的作用就是返回队列头部的值，并且我们可以通过这个函数来修改队列头部的值，比如说下面的代码：

using namespace std;
int main()
{
	queue<int> q1;
	q1.push(1);
	q1.push(2);
	q1.push(3);
	q1.push(4);
	cout <<"front 指向的元素为：" << q1.front() << endl;
	q1.front() = 10;
	cout << "front 指向的元素为：" << q1.front() << endl;
	return 0;
}

这段代码的运行结果如下：

back

这个函数的作用与front函数相反，这个函数就是返回队列尾部的值并且同样可以对其进行修改，比如说下面的代码：

int main()
{
	queue<int> q1;
	q1.push(1);
	q1.push(2);
	q1.push(3);
	q1.push(4);
	cout << "back 指向的元素为：" << q1.back() << endl;
	q1.back() = 10;
	cout << "back 指向的元素为：" << q1.back() << endl;
	return 0;
}

queue的元素个数

size函数的作用就是返回队列中元素的个数，比如说下面的代码：

int main()
{
	queue<int> q1;
	q1.push(1);
	q1.push(2);
	q1.push(3);
	q1.push(4);
	cout << "q1的元素个数为：" << q1.size() << endl;
	q1.push(5);
	cout << "q1的元素个数为：" << q1.size() << endl;
	return 0;
}

这段代码的运行结果如下：

queue中元素的删除

在队列中删除元素得用到pop函数，这个函数可以将队列中队头的数据进行删除，比如说下面的代码：

int main()
{
	queue<int> q1;
	q1.push(1);
	q1.push(2);
	q1.push(3);
	q1.push(4);
	cout << "q1的元素个数为：" << q1.size() << endl;
	q1.pop();
	cout << "q1的元素个数为：" << q1.size() << endl;
	return 0;
}

这段代码的运行结果如下：

empty

当我们想看看queue对象是否为空的时候就可以用到empty函数，这个函数的功能就是检查对象的内容是否为空，如果为空的话这个函数就会返回true，如果不为空的话这个函数就会返回flase。

queue的数据交换

如果我们想将两个queue对象的数据进行交换的话，我们这里就可以使用swap函数，这里为了防止使用者用错了方法，库中还提供了另外一种使用的形式：

我们来看看下面的代码：

int main()
{
	queue<int> q1;
	q1.push(1);
	q1.push(2);
	q1.push(3);
	q1.push(4);
	queue<int> q2;
	q2.push(5);
	q2.push(6);
	q2.push(7);
	q2.push(8);
	q1.swap(q2);
	swap(q1, q2);
	return 0;
}

我们可以通过调试来看到在swap函数执行之前两个对象的内容为：

执行了第一个swap函数之后，两个对象的内容进行了交换：

当我们再执行另一种swap函数之后对象的数据如下：

那么这就是swap函数的作用。