C/C++编程：STL双端队列deque与queue

àì夳堔傛蜴生んèń 2022-05-17 00:08 241阅读 0赞

# Deque #

*  是序列式容器：元素的位置与插入时机有关，与元素值无关
 *  可以通过索引随机存取元素
 *  `std::deque` （ double-ended queue ，双端队列）是有下标顺序容器，它允许**在其首尾两端快速插入及删除**。另外，在 deque 任一端插入或删除不会非法化指向其余元素的指针或引用。
 *  与std::vector相反，deque的元素不是连续储存的

## 构造 ##

![20210308175429943.png][]

### std::deque::deque ###

#include <deque>
 #include <string>
 #include <iostream>
 
 template<typename T>
 std::ostream& operator<<(std::ostream& s, const std::deque<T>& v)
 {
 s.put('[');
 char comma[3] = {'\0', ' ', '\0'};
 for (const auto& e : v) {
 s << comma << e;
 comma[0] = ',';
 }
 return s << ']';
 }
 
 int main() 
 {
 // C++11 初始化器列表语法：
 std::deque<std::string> words1 {"the", "frogurt", "is", "also", "cursed"};
 std::cout << "words1: " << words1 << '\n';
 
 // words2 == words1
 std::deque<std::string> words2(words1.begin(), words1.end());
 std::cout << "words2: " << words2 << '\n';
 
 // words3 == words1
 std::deque<std::string> words3(words1);
 std::cout << "words3: " << words3 << '\n';
 
 // words4 为 {"Mo", "Mo", "Mo", "Mo", "Mo"}
 std::deque<std::string> words4(5, "Mo");
 std::cout << "words4: " << words4 << '\n';
 }

![20210308174546927.png][]

## std::deque::assign ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70][]

#include <deque>
 #include <iostream>
 
 int main()
 {
 std::deque<char> characters;
 
 characters.assign(5, 'a');
 
 for (char c : characters) {
 std::cout << c << ' ';
 } 
 
 characters.assign({'\n', 'C', '+', '+', '1', '1', '\n'});
 
 for (char c : characters) {
 std::cout << c;
 }
 }

![20210308175406231.png][]

## 元素访问 ##

![20210308175513216.png][]

### std::deque::at ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1][]

#include <iostream>
 #include <deque>
 
 int main()
 {
 std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
 
 // Set element 1
 data.at(1) = 88;
 
 // Read element 2
 std::cout << "Element at index 2 has value " << data.at(2) << '\n';
 
 std::cout << "data size = " << data.size() << '\n';
 
 try {
 // Set element 6
 data.at(6) = 666;
 } catch (std::out_of_range const& exc) {
 std::cout << exc.what() << '\n';
 }
 
 // Print final values
 std::cout << "data:";
 for (int elem : data)
 std::cout << " " << elem;
 std::cout << '\n';
 }

## ![20210308175609317.png][] ##

### std::deque::operator\[\] ###

返回位于指定位置 `pos` 的元素的引用。不进行边界检查。通过此运算符访问不存在的元素是未定义行为。

#include <deque>
 #include <iostream>
 
 int main()
 {
 std::deque<int> numbers {2, 4, 6, 8};
 
 std::cout << "Second element: " << numbers[1] << '\n';
 
 numbers[0] = 5;
 
 std::cout << "All numbers:";
 for (auto i : numbers) {
 std::cout << ' ' << i;
 }
 std::cout << '\n';
 }

![20210308175740667.png][]

### std::deque::front、std::deque::back ###

> std::deque::front

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2][]

> std::deque::back

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3][]

#include <deque>
 #include <iostream>
 
 int main()
 {
 std::deque<char> letters {'o', 'm', 'g', 'w', 't', 'f'};
 
 if (!letters.empty()) {
 std::cout << "The first character is: " << letters.front() << '\n';
 std::cout << "The last character is: " << letters.back() << '\n';
 } 
 }

## 容量 ##

![20210309090335839.png][]

### std::deque::empty ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4][]

#include <deque>
 #include <iostream>
 
 int main()
 {
 std::deque<int> numbers;
 std::cout << "Initially, numbers.empty(): " << numbers.empty() << '\n';
 
 numbers.push_back(42);
 numbers.push_back(13317); 
 std::cout << "After adding elements, numbers.empty(): " << numbers.empty() << '\n';
 }

# ![20210309090424898.png][] #

# std::deque::size #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 5][]

#include <deque>
 #include <iostream>
 
 int main()
 { 
 std::deque<int> nums {1, 3, 5, 7};
 
 std::cout << "nums contains " << nums.size() << " elements.\n";
 }

# ![20210309090517275.png][] #

### std::deque::max\_size ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 6][]

#include <iostream>
 #include <deque>
 
 int main()
 {
 std::deque<char> s;
 std::cout << "Maximum size of a 'deque' is " << s.max_size() << "\n";
 }

# ![20210309090607548.png][] #

### std::deque::shrink\_to\_fit ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 7][]

#include <deque>
 
 int main() {
 std::deque<int> nums(1000, 42);
 nums.push_front(1);
 nums.pop_front();
 
 nums.clear();
 
 // nums 现在不含项目，但它仍保有分配的内存。
 // 调用 shrink_to_fit 可能会释放任何不使用的内存。
 nums.shrink_to_fit();
 }

## 修改器 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 8][]

### std::deque::clear ###

# ![20210309090922313.png][] #

#include <algorithm>
 #include <iostream>
 #include <deque>
 
 int main()
 {
 std::deque<int> container{1, 2, 3};
 
 auto print = [](const int& n) { std::cout << " " << n; };
 
 std::cout << "Before clear:";
 std::for_each(container.begin(), container.end(), print);
 std::cout << "\nSize=" << container.size() << '\n';
 
 std::cout << "Clear\n";
 container.clear();
 
 std::cout << "After clear:";
 std::for_each(container.begin(), container.end(), print);
 std::cout << "\nSize=" << container.size() << '\n';
 }

# ![20210309090941662.png][] #

### std :: [deque][] :: insert ###

作用：插入元素到指定位置

// inserting into a deque
 #include <iostream>
 #include <deque>
 #include <vector>
 
 int main ()
 {
 std::deque<int> mydeque;
 
 // set some initial values:
 for (int i=1; i<6; i++) mydeque.push_back(i); // 1 2 3 4 5
 
 std::deque<int>::iterator it = mydeque.begin();
 ++it;
 
 it = mydeque.insert (it,10); // 1 10 2 3 4 5
 // "it" now points to the newly inserted 10
 
 mydeque.insert (it,2,20); // 1 20 20 10 2 3 4 5
 // "it" no longer valid!
 
 it = mydeque.begin()+2;
 
 std::vector<int> myvector (2,30);
 mydeque.insert (it,myvector.begin(),myvector.end());
 // 1 20 30 30 20 10 2 3 4 5
 
 std::cout << "mydeque contains:";
 for (it=mydeque.begin(); it!=mydeque.end(); ++it)
 std::cout << ' ' << *it;
 std::cout << '\n';
 
 return 0;
 }

### std :: [deque][] :: emplace ###

作用：构造并插入元素到指定位置

// deque::emplace
 #include <iostream>
 #include <deque>
 
 int main ()
 {
 std::deque<int> mydeque = {10,20,30};
 
 auto it = mydeque.emplace ( mydeque.begin()+1, 100 );
 mydeque.emplace ( it, 200 );
 mydeque.emplace ( mydeque.end(), 300 );
 
 std::cout << "mydeque contains:";
 for (auto& x: mydeque)
 std::cout << ' ' << x;
 std::cout << '\n';
 
 return 0;
 }

#include <iostream>
 #include <string>
 #include <deque>
 
 struct A {
 std::string s;
 A(std::string str) : s(std::move(str)) { std::cout << " constructed\n"; }
 A(const A& o) : s(o.s) { std::cout << " copy constructed\n"; }
 A(A&& o) : s(std::move(o.s)) { std::cout << " move constructed\n"; }
 A& operator=(const A& other) {
 s = other.s;
 std::cout << " copy assigned\n";
 return *this;
 }
 A& operator=(A&& other) {
 s = std::move(other.s);
 std::cout << " move assigned\n";
 return *this;
 }
 };
 
 int main()
 {
 std::deque<A> container;
 
 std::cout << "construct 2 times A:\n";
 A two { "two" };
 A three { "three" };
 
 std::cout << "emplace:\n";
 container.emplace(container.end(), "one");
 
 std::cout << "emplace with A&:\n";
 container.emplace(container.end(), two);
 
 std::cout << "emplace with A&&:\n";
 container.emplace(container.end(), std::move(three));
 
 std::cout << "content:\n";
 for (const auto& obj : container)
 std::cout << ' ' << obj.s;
 std::cout << '\n';
 }

### std::deque::emplace\_front ###

在开始时构造并插入元素

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 9][]

// deque::emplace_from
 #include <iostream>
 #include <deque>
 
 int main ()
 {
 std::deque<int> mydeque = {10,20,30};
 
 mydeque.emplace_front (111);
 mydeque.emplace_front (222);
 
 std::cout << "mydeque contains:";
 for (auto& x: mydeque)
 std::cout << ' ' << x;
 std::cout << '\n';
 
 return 0;
 }

### ![20210309092259429.png][] ###

### std::deque::emplace\_back ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 10][]

// deque::emplace_from
 #include <iostream>
 #include <deque>
 
 int main ()
 {
 std::deque<int> mydeque = {10,20,30};
 
 mydeque.emplace_back (100);
 mydeque.emplace_back (200);
 
 std::cout << "mydeque contains:";
 for (auto& x: mydeque)
 std::cout << ' ' << x;
 std::cout << '\n';
 
 return 0;
 }

#include <deque>
 #include <string>
 #include <iostream>
 
 struct President
 {
 std::string name;
 std::string country;
 int year;
 
 President(std::string p_name, std::string p_country, int p_year)
 : name(std::move(p_name)), country(std::move(p_country)), year(p_year)
 {
 std::cout << "I am being constructed.\n";
 }
 President(President&& other)
 : name(std::move(other.name)), country(std::move(other.country)), year(other.year)
 {
 std::cout << "I am being moved.\n";
 }
 President& operator=(const President& other) = default;
 };
 
 int main()
 {
 std::deque<President> elections;
 std::cout << "emplace_back:\n";
 elections.emplace_back("Nelson Mandela", "South Africa", 1994);
 
 std::deque<President> reElections;
 std::cout << "\npush_back:\n";
 reElections.push_back(President("Franklin Delano Roosevelt", "the USA", 1936));
 
 std::cout << "\nContents:\n";
 for (President const& president: elections) {
 std::cout << president.name << " was elected president of "
 << president.country << " in " << president.year << ".\n";
 }
 for (President const& president: reElections) {
 std::cout << president.name << " was re-elected president of "
 << president.country << " in " << president.year << ".\n";
 }
 }

### std::deque::push\_front ###

void push_front（const value_type＆val）;
    void push_front（value_type && val）;

在[双端队列][Link 1]容器的当前位置的第一个元素之前插入一个新元素。*val*的内容被复制（或移动）到插入的元素。

// deque::push_front
 #include <iostream>
 #include <deque>
 
 int main ()
 {
 std::deque<int> mydeque (2,100); // two ints with a value of 100
 mydeque.push_front (200);
 mydeque.push_front (300);
 
 std::cout << "mydeque contains:";
 for (std::deque<int>::iterator it = mydeque.begin(); it != mydeque.end(); ++it)
 std::cout << ' ' << *it;
 std::cout << '\n';
 
 return 0;
 }

![20210309092102972.png][]

### std::deque::push\_back ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 11][]

#include <deque>
 #include <iostream>
 #include <iomanip>
 
 int main()
 {
 std::deque<std::string> letters;
 
 letters.push_back("abc");
 std::string s = "def";
 letters.push_back(std::move(s));
 
 std::cout << "deque holds: ";
 for (auto&& i : letters) std::cout << std::quoted(i) << ' ';
 std::cout << "\nMoved-from string holds " << std::quoted(s) << '\n';
 }

### ![20210309091531316.png][] ###

### std::deque::pop\_front ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 12][]

### std::deque::pop\_back ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 13][]

#include <deque>
 #include <iostream>
 
 template<class T>
 void print(T const & xs)
 {
 std::cout << "[ ";
 for(auto && x : xs) {
 std::cout << x << ' ';
 }
 std::cout << "]\n";
 }
 
 int main()
 {
 std::deque<int> numbers;
 
 print(numbers); 
 
 numbers.push_back(5);
 numbers.push_back(3);
 numbers.push_back(4);
 
 print(numbers); 
 
 numbers.pop_back();
 
 print(numbers); 
 }

### ![20210309091909307.png][] ###

### std::deque::erase ###

作用：擦除指定位置的元素

#include <deque>
 #include <iostream>
 
 
 int main( )
 {
 std::deque<int> c{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 for (auto &i : c) {
 std::cout << i << " ";
 }
 std::cout << '\n';
 
 c.erase(c.begin());
 
 for (auto &i : c) {
 std::cout << i << " ";
 }
 std::cout << '\n';
 
 c.erase(c.begin()+2, c.begin()+5);
 
 for (auto &i : c) {
 std::cout << i << " ";
 }
 std::cout << '\n';
 }

# ![20210309091350279.png][] #

### std::deque::resize ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 14][]

#include <iostream>
 #include <deque>
 int main()
 {
 std::deque<int> c = {1, 2, 3};
 std::cout << "The deque holds: ";
 for(auto& el: c) std::cout << el << ' ';
 std::cout << '\n';
 c.resize(5);
 std::cout << "After resize up to 5: ";
 for(auto& el: c) std::cout << el << ' ';
 std::cout << '\n';
 c.resize(2);
 std::cout << "After resize down to 2: ";
 for(auto& el: c) std::cout << el << ' ';
 std::cout << '\n';
 }

# ![20210309092505483.png][] #

### std::deque::swap ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 15][]

#include <iostream>
 #include <deque>
 
 template<class Os, class Co> Os& operator<<(Os& os, const Co& co) {
 os << "{";
 for (auto const& i : co) { os << ' ' << i; }
 return os << " } ";
 }
 
 int main()
 {
 std::deque<int> a1{1, 2, 3}, a2{4, 5};
 
 auto it1 = std::next(a1.begin());
 auto it2 = std::next(a2.begin());
 
 int& ref1 = a1.front();
 int& ref2 = a2.front();
 
 std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
 a1.swap(a2);
 std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' ' << ref2 << '\n';
 
 // 注意交换后迭代器与引用保持与其原来的元素关联，例如指向 'a1' 中值为 2 的元素的 it1 仍指向同一元素，
 // 尽管此元素被移动到 'a2' 中。
 }

# ![20210309092706563.png][] #

## 其他 ##

![2021030909282532.png][]

### ==,!=,<,<=,>,>=,<=> ###

作用：按照字典顺序比较 deque 中的值

#include <iostream>
 #include <deque>
 
 int main()
 {
 std::deque<int> alice{1, 2, 3};
 std::deque<int> bob{7, 8, 9, 10};
 std::deque<int> eve{1, 2, 3};
 
 std::cout << std::boolalpha;
 
 // 比较不相等的容器
 std::cout << "alice == bob returns " << (alice == bob) << '\n';
 std::cout << "alice != bob returns " << (alice != bob) << '\n';
 std::cout << "alice < bob returns " << (alice < bob) << '\n';
 std::cout << "alice <= bob returns " << (alice <= bob) << '\n';
 std::cout << "alice > bob returns " << (alice > bob) << '\n';
 std::cout << "alice >= bob returns " << (alice >= bob) << '\n';
 
 std::cout << '\n';
 
 // 比较相等的容器
 std::cout << "alice == eve returns " << (alice == eve) << '\n';
 std::cout << "alice != eve returns " << (alice != eve) << '\n';
 std::cout << "alice < eve returns " << (alice < eve) << '\n';
 std::cout << "alice <= eve returns " << (alice <= eve) << '\n';
 std::cout << "alice > eve returns " << (alice > eve) << '\n';
 std::cout << "alice >= eve returns " << (alice >= eve) << '\n';
 }

# ![20210309092755526.png][] #

### std::swap(std::deque) ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 16][]

#include <algorithm>
 #include <iostream>
 #include <deque>
 
 int main()
 {
 std::deque<int> alice{1, 2, 3};
 std::deque<int> bob{7, 8, 9, 10};
 
 auto print = [](const int& n) { std::cout << " " << n; };
 
 // 打印交换前的状态
 std::cout << "alice:";
 std::for_each(alice.begin(), alice.end(), print);
 std::cout << '\n';
 std::cout << "bob :";
 std::for_each(bob.begin(), bob.end(), print);
 std::cout << '\n';
 
 std::cout << "-- SWAP\n";
 std::swap(alice,bob);
 
 // 打印交换后的状态
 std::cout << "alice:";
 std::for_each(alice.begin(), alice.end(), print);
 std::cout << '\n';
 std::cout << "bob :";
 std::for_each(bob.begin(), bob.end(), print);
 std::cout << '\n';
 }

# ![20210309092911387.png][] #

### std::erase, std::erase\_if (std::deque) ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 17][]

#include <iostream>
 #include <numeric>
 #include <deque>
 
 void print_container(const std::deque<char>& c)
 {
 for (auto x : c) {
 std::cout << x << ' ';
 }
 std::cout << '\n';
 }
 
 int main()
 {
 std::deque<char> cnt(10);
 std::iota(cnt.begin(), cnt.end(), '0');
 
 std::cout << "Init:\n";
 print_container(cnt);
 
 auto erased = std::erase(cnt, '3');
 std::cout << "Erase \'3\':\n";
 print_container(cnt);
 
 std::erase_if(cnt, [](char x) { return (x - '0') % 2 == 0; });
 std::cout << "Erase all even numbers:\n";
 print_container(cnt);
 std::cout << "In all " << erased << " even numbers were erased.\n";
 }

# ![20210309093007336.png][] #

# queue #

**头文件：** \#include<queue>

**实例化**： queue<类型\[, 存储容器\]>QueueName

## **成员函数** ##

<table style="width:437.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:194.4pt;"> bool&nbsp;empty(); </td> 
 <td style="vertical-align:top;width:243pt;"> 队列为空返回 true&nbsp;否则返回false. </td> 
 </tr> 
 <tr> 
 <td style="width:194.4pt;"> void&nbsp;pop(); </td> 
 <td style="width:243pt;"> 删除队列的一个元素。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:194.4pt;"> void&nbsp;push( const&nbsp;<a href="http://64.4.48.250/cgi-bin/containers.html" rel="nofollow">TYPE</a>&nbsp;&amp;val ); </td> 
 <td style="vertical-align:top;width:243pt;"> 将 val 元素加入队列。 </td> 
 </tr> 
 <tr> 
 <td style="width:194.4pt;"> size_type size(); </td> 
 <td style="width:243pt;"> 返当前队列中的元素数目 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:194.4pt;"> TYPE &amp;back(); </td> 
 <td style="vertical-align:top;width:243pt;"> 返回一个引用，指向队列的最后一个元素。 </td> 
 </tr> 
 <tr> 
 <td style="width:194.4pt;"> TYPE &amp;front(); </td> 
 <td style="width:243pt;"> 返回队列第一个元素的引用。 </td> 
 </tr> 
 </tbody> 
</table>

## **实例程序** ##

#include <iostream>
 #include <queue>
 #include <algorithm>
 
 using namespace std;
 
 void main()
 {
 	queue<int>s;
 	s.push(1);
 	s.push(2); //将val加入队列
 	s.push(3);
 	cout << "当前队列中的元素数目" << s.size() << endl;
 	cout << "返回队列第一个元素的引用" << s.front() << endl;
 	cout << "返回队列最后一个元素的引用" << s.back() << endl;
 	// 1 2 3
 	s.pop(); //删除队列的第一个元素，队列：先进先出
 	// 2 3 
 	cout << "返回队列第一个元素的引用" << s.front() << endl;
 	cout << "返回队列最后一个元素的引用" << s.back() << endl;
 	if (s.empty()) cout << "Is empty" << endl; //队列为真返回空
 	else cout << "Is not empty" << endl;
 	system("pause");
 }

# C++ 清空队列(queue)的几种方法 #

## 直接用空的队列对象赋值 ##

queue<int> q1;
 // process
 // ...
 q1 = queue<int>();

## 遍历出队列 ##

while (!Q.empty()) Q.pop();

## 使用swap，这种是最高效的，定义clear，保持STL容器的标准。 ##

void clear(queue<int>& q) {
 queue<int> empty;
 swap(empty, q);
 }

[20210308175429943.png]: /images/20220517/e2249948878c413b9cdc69d6a7e7ee9c.png
[20210308174546927.png]: /images/20220517/ff2b9c5787b44c068ed47799d2a0e6af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20220517/b431ac834d054140a603d9ca8f9a8d61.png
[20210308175406231.png]: /images/20220517/3cb62027515f41cea18deafec9002b72.png
[20210308175513216.png]: /images/20220517/aa3d9721c8c64cfca5de4d80cb337755.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20220517/001ea12159fc4261891787d7ff78dcf1.png
[20210308175609317.png]: /images/20220517/fc06df1ef5da4ff79cb4332d1ce94580.png
[20210308175740667.png]: /images/20220517/90965c950c2849b19a5c7cfd1285d24a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: /images/20220517/f3d9faf8f9e94df7b2edd7ae36fed0ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: /images/20220517/60c1e31abac245dda12b1b97c0a86aaf.png
[20210309090335839.png]: /images/20220517/c121e5c211ce417990c1b46ff5021893.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]: /images/20220517/0b4a358bf3984944bf3f5129560f9491.png
[20210309090424898.png]: /images/20220517/58e85b97998f4d65aed98a499dfcd365.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 5]: /images/20220517/10aff96db38d41f291fdd8dbf7943d27.png
[20210309090517275.png]: /images/20220517/330e1508c230423a9fb25acac652770c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 6]: /images/20220517/ef92404828a04240bd1dee9f2c0a6880.png
[20210309090607548.png]: /images/20220517/975fcbd9cf7e4eed9d1538f8a007915f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 7]: /images/20220517/c99d8e0b61614b379e5d0924e59a5bc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 8]: /images/20220517/1cb57f504e864d8da3748fe752e11496.png
[20210309090922313.png]: /images/20220517/d7c6dcf0d963450c899bf00c458f9df5.png
[20210309090941662.png]: /images/20220517/9828f72d832642b2bd4e761b2b11a9fe.png
[deque]: http://www.cplusplus.com/reference/deque/deque/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 9]: /images/20220517/bf45736157c4413d8de35cfce1e5f9ca.png
[20210309092259429.png]: /images/20220517/2d25639454bf42ce9692b9674e9865ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 10]: /images/20220517/aad3c94eb5ef4eb9b80ae1b7e7f549cd.png
[Link 1]: http://www.cplusplus.com/deque
[20210309092102972.png]: /images/20220517/67cc6ae2d6ed407a99f958ffc0e6a9cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 11]: /images/20220517/ed7b0eea121943a7957846a2ea8395e1.png
[20210309091531316.png]: /images/20220517/4f195f1ec4cd454aaef1ce9197515b00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 12]: /images/20220517/67be8dcf5e8741c199e23b79a2504e27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 13]: /images/20220517/20497b257f984e2aa57ffa7aad5b47d8.png
[20210309091909307.png]: /images/20220517/d352495435894e3e9f2e49673a4acd08.png
[20210309091350279.png]: /images/20220517/dc0147f7265446208af32ce7d105f603.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 14]: /images/20220517/115f4b05481c4ad4bb636851f0de09be.png
[20210309092505483.png]: /images/20220517/15e012480f48412db1c0dc87071f5ed1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 15]: /images/20220517/db98698a84b54da28c71d076eff918d3.png
[20210309092706563.png]: /images/20220517/773dd8d964114b8a974a3fe7796d0b60.png
[2021030909282532.png]: /images/20220517/7dd135850aed4a11926125cdfe7a5abf.png
[20210309092755526.png]: /images/20220517/189306acb6e14f4a92ec6408f22f5b0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 16]: /images/20220517/ff5b47a590244162bf4f3daf8e25b1b1.png
[20210309092911387.png]: /images/20220517/c57c8597df494a98808e27585fb7cd7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 17]: /images/20220517/e3817ec96faa4ae6bcd30d7fdf42fe1e.png
[20210309093007336.png]: /images/20220517/e5105de1d57940f5b253dbc189b25b5e.png