C++容器适配器操作总结（代码+示例）

---

顺序容器操作详解：
顺序容器操作总结

stack

stack是一种容器适配器，专门设计用于在LIFO上下文（后进先出）中操作，在LIFO上下文中，仅从容器的一端插入和提取元素。

stack作为容器适配器实现，它们是使用特定容器类的封装对象作为其基础容器的类，提供了一组特定的成员函数来访问其元素。元素从特定容器的尾部被推入*/弹出，这被称为堆栈的*顶部。

容器应支持以下操作：

• empty
• size
• back
• push_back
• pop_back

标准容器类vector，deque 和list满足这些要求。默认情况下，使用标准容器 deque来作为底层容器。

---

stack对象的构造

stack() = default;
explicit stack (const container_type& _Cont);
explicit stack (container_type&& ctnr = container_type());

stack<int> s = { 1,2,3,4,5 };	//error 不能直接初始化
//如下，可以使用stack底层容器进行初始化
deque<int> dq = { 1,2,3,4,5 };
stack<int> s(dq);

示例代码：

int main(){
	stack<int> a{ 1,2,3,4,5,6 };	//ERROR：无法使用聚合初始化
	
	//使用临时的deque来间接创建stack对象
	deque<int> temp{ 1,2,3,4,5,6 };
	list<int> temp2{ 1,2,3,4,5,6 };
	stack<int> dst(temp);	
	stack<int> dst2(deque<int>{1, 2, 3, 4, 5, 6});	//创建临时对象
	return 0;
}

---

stack的操作

Ty& top();						//获取顶部元素
void pop();						//删除顶部元素
void push(const Ty& val);		//入栈
void swap(stack& sk);			//交换两个stack
size_t size();					//获取元素个数
bool empty();					//判空

template <class... _Valty>
void emplace(_Valty&&... _Val);	//就地构造，提升效率

示例代码：

int main()
{
	//stack a = { 1,2,3,4,5 };	//不能直接初始化
	deque<int> temp{ 1,2,3,4,5,6 };
	stack<int> a(temp);	//使用deque间接初始化
	while (!a.empty()){
		auto elem = a.top();
		cout << elem << " ";
		a.pop();
	}
	a.push(555);
	a.pop();
	return 0;
}

运行如下：

注意：pop出栈不会传递参数，如果要获取栈顶元素请首先使用top函数。

示例：括号匹配

问题： 输入一组带括号的序列 ( [ { 等，判断你输入的括号组合是否正确：
例如： ( [ { ] ] ) 为一组正确组合； ( [ ))) 不是一组正确组合

int main(){
	stack<char> a;
	cout << "请输入括号序列: ";
	string vair;
	cin >> vair;
	char temp;
	bool isok = true;
	for (auto& x : vair)
	{
		switch (x)
		{
		case '(':
		case '[':
		case '{':
			//左括号入栈
			a.push(x);
			break;
		case ')':
			if (!a.empty())
			{
				temp = a.top();
				if (temp != '(') {
					isok = false;
				}
				a.pop();
			}
			break;
		case ']':
			if (!a.empty())
			{
				temp = a.top();
				if (temp != '[') {
					isok = false;
				}
				a.pop();
			}
			break;
		case '}':
			if (!a.empty())
			{
				temp = a.top();
				if (temp != '{') {
					isok = false;
				}
				a.pop();
			}
			break;
		}  
	}
	if (a.empty() && isok)
	{
		cout << "括号匹配！\n";
	}
	else
	{
		cout << "括号不匹配!\n";
	}
	return 0
}

运行如下：

queue

FIFO队列

queue是一种容器适配器，专门设计用于在FIFO上下文中（先进先出）进行操作，在FIFO上下文中，将元素插入到容器的一端，并从另一端提取元素。

queue被实现为容器适配器，它们是使用特定容器类的封装对象作为其基础容器的类，提供了一组特定的成员函数来访问其元素。元素被推入特定容器的*“后部”，并从其“前部”弹出*。

基础容器可以是标准容器类模板之一，也可以是其他一些专门设计的容器类。此基础容器应至少支持以下操作：

• empty
• size
• front
• back
• push_back
• pop_front

标准容器类 deque和list满足这些要求。默认情况下，如果未为特定容器指定容器类队列

类实例化，默认用标准容器 deque。

---

queue对象的构造

queue() = default;
explicit queue(const _Container& _Cont);
explicit queue(_Container&& _Cont);

示例代码：

int main()
{
	deque<string> temp{ "awdad","ojdow","nive" };
	queue<string> b(temp);
	queue<int> a(deque<int>{1, 2, 3, 4, 5, 6});
	return 0;
}

---

queue其他操作

Ty& back();						//获取头部元素
Ty& front();					//获取尾部元素
void pop();						//删除头部元素
void push(const Ty& val);		//入队(从尾部)
void swap(stack& sk);			//交换两个queue
size_t size();					//获取元素个数
bool empty();					//判空

template <class... _Valty>
void emplace(_Valty&&... _Val);	//就地构造，提升效率

示例代码：

int main(){
	deque<string> temp{ "a","b","c","d","e","f"};
	while (!b.empty()){
		auto elem = b.front();	//获取头部元素
		auto elem2 = b.back();	//获取尾部元素
		cout << "front: " << elem << "\tback: " << elem2 << endl;
		b.pop();			//依次出队
	}
	return 0;
}

运行结果：

---

示例：模拟病人看病

void travel(const queue<string>& p){
	//方便进行遍历
	queue<string>* temp=new queue<string>(p);	//创建一个临时的指针对象
	while (!temp->empty()){
		cout << temp->front() << "  ";
		temp->pop();
	}
	cout << endl;
	delete temp;
	temp = nullptr;
}
int main(){
	queue<string> a;
	string name;
	while (true)
	{
		int choice = 0;
		cout << "1.排队  2.看医生  3.查看队伍  0.下班\n";
		cin >> choice;
		switch (choice)
		{
		case 1:
			cout << "请输入加入队列的病人名称: ";
			cin >> name;
			a.push(name);
			break;
		case 2:
			if (a.empty()) {
				cout << "没有排队的病人!\n";
			}
			else {
				cout << "当前病人: " << a.front() << endl;
			}
			a.pop();
			break;
		case 3:
			cout << "当前队伍: ";
			travel(a);
			break;
		case 0:
			cout << "下班了，请病人们明天再来!\n";
			goto end;
			break;
		}
	}
end:;
	return 0;
}

---

priority_queue

priority_que(优先级队列)是一种容器适配器，经过专门设计，以使其按照某些*严格的弱排序（strict weak ordering）*标准，其第一个元素始终是其中包含的最大元素。

严格是说在判断的时候会用"<“，而不是”<=“，弱排序是因为，一旦”<“成立便认为存在”<“关系，返回ture，而忽略了”=“关系和”>"区别，把它们归结为false。

此上下文类似于堆，可以在任何时候插入元素，并且只能检索最大堆元素（优先级队列顶部的元素）。

优先级队列被实现为容器适配器，它们是使用特定容器类的封装对象作为其基础容器的类，提供了一组特定的成员函数来访问其元素。元素被弹出从特定容器的*“后退”，称为优先级队列的顶部*。

基础容器可以是任何标准容器类模板或某些其他专门设计的容器类。该容器应可通过随机访问迭代器访问并支持以下操作：

• empty()
• size()
• front()
• push_back()
• pop_back()

标准容器类 vector和 deque满足这些要求。默认情况下，如果未为特定容器指定容器类

priority_queue 类实例化，默认使用vector作为底层容器。

需要支持随机访问迭代器，以始终在内部保持堆结构。容器适配器通过自动调用算法函数(make_heap， push_heap，pop_heap )维持堆结构。

---

priority_queue对象的构造

priority_queue() = default;
explicit priority_queue(const _Pr& _Pred);

priority_queue (const _Pr& Pred, const Container& Cont);

priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Container& _Cont);
    
priority_queue(_InIt _First, _InIt _Last);
    
priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred);

---

priority_que其他操作

Ty& top();
void pop();
void push(Ty& val);
void swap();
size_t size();
bool empty();

template <class... _Valty>
    void emplace(_Valty&&... _Val)