寫在前面

這一篇部落格系統學習一下C++中stack這個容器。根據維基百科——堆疊解釋：

堆疊（英語：stack）又稱為棧或堆疊，是電腦科學中一種特殊的串列形式的抽象資料型別，其特殊之處在於只能允許在連結串列或陣列的一端（稱為堆疊頂端指標，英語：top）進行加入資料（英語：push）和輸出資料（英語：pop）的運算。另外棧也可以用一維陣列或連結串列的形式來完成。堆疊的另外一個相對的操作方式稱為佇列。

由於堆疊資料結構只允許在一端進行操作，因而按照後進先出（LIFO, Last In First Out）的原理運作。

與之前一樣，主要根據CPlusPlus官網stack容器介紹內容進行整理：

stack類與標頭檔案包含

stack標頭檔案引用如下：

#include <stack> 

stack::stack

// constructing stacks
#include <iostream>       // std::cout
#include <stack>          // std::stack
#include <vector>         // std::vector
#include <deque>          // std::deque

int main ()
{
  std
 
::deque<int> mydeque (3,100);          // deque with 3 elements
  std::vector<int> myvector (2,200);        // vector with 2 elements

  std::stack<int> first;                    // empty stack
  std::stack<int> second (mydeque);         // stack initialized to copy of deque

  std::stack
 
<int,std::vector<int> > third;  // empty stack using vector
  std::stack<int,std::vector<int> > fourth (myvector);

  std::cout << "size of first: " << first.size() << '\n';
  std::cout << "size of second: " << second.size() << '\n';
  std::cout << "size of third: " << third.size() << '\n';
  std::cout << "size of fourth: " << fourth.size() << '\n';

  return 0;
}
//
//Output:
//size of first: 0
//size of second: 3
//size of third: 0
//size of fourth: 2

從以上程式碼可以得知stack可以直接建立一個空白的，也可以由queue和vector建立。

stack-Member functions

1.stack::empty
測試容器是否為空，返回堆疊是否為空：即其大小是否為零。該成員函式有效地將成員空的底層容器物件呼叫為空。

程式碼如下：

// stack::empty
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;
  int sum (0);

  for (int i=1;i<=10;i++) mystack.push(i);

  while (!mystack.empty())
  {
     sum += mystack.top();
     mystack.pop();
  }

  std::cout << "total: " << sum << '\n';

  return 0;
}
\\Output:
\\total: 55

2.stack::size
返回大小，返回堆疊中元素的數量。該成員函式有效地呼叫底層容器物件的成員大小。

程式碼如下：

// stack::size
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> myints;
  std::cout << "0. size: " << myints.size() << '\n';

  for (int i=0; i<5; i++) myints.push(i);
  std::cout << "1. size: " << myints.size() << '\n';

  myints.pop();
  std::cout << "2. size: " << myints.size() << '\n';

  return 0;
}
//Output:
//0. size: 0
//1. size: 5
//2. size: 4

3.stack::top
訪問下一個元素，返回堆疊中頂層元素的引用。由於堆疊是後進先出容器，頂層元素是插入到堆疊中的最後一個元素。該成員函式有效地呼叫底層容器物件的成員。

程式碼如下：

// stack::top
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;

  mystack.push(10);
  mystack.push(20);

  mystack.top() -= 5;

  std::cout << "mystack.top() is now " << mystack.top() << '\n';

  return 0;
}
//Output:
//mystack.top() is now 15

4.stack::push
插入元素，在堆疊的頂部插入一個新元素，位於當前頂層元素的上方。 這個新元素的內容被初始化為val的副本。該成員函式有效地呼叫底層容器物件的成員函式push_back。

程式碼如下：

// stack::push/pop
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;

  for (int i=0; i<5; ++i) mystack.push(i);

  std::cout << "Popping out elements...";
  while (!mystack.empty())
  {
     std::cout << ' ' << mystack.top();
     mystack.pop();
  }
  std::cout << '\n';

  return 0;
}

4.stack::emplace
構建並插入元素，在堆疊頂部新增一個新元素，位於當前頂層元素上方。 這個新元素是通過建構函式的引數傳遞引數構建的。該成員函式有效地呼叫底層容器的成員函式emplace_back，並轉發引數。

程式碼如下：

// stack::emplace
#include <iostream>       // std::cin, std::cout
#include <stack>          // std::stack
#include <string>         // std::string, std::getline(string)

int main ()
{
  std::stack<std::string> mystack;

  mystack.emplace ("First sentence");
  mystack.emplace ("Second sentence");

  std::cout << "mystack contains:\n";
  while (!mystack.empty())
  {
    std::cout << mystack.top() << '\n';
    mystack.pop();
  }

  return 0;
}

5.stack::pop

// stack::push/pop
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;

  for (int i=0; i<5; ++i) mystack.push(i);

  std::cout << "Popping out elements...";
  while (!mystack.empty())
  {
     std::cout << ' ' << mystack.top();
     mystack.pop();
  }
  std::cout << '\n';

  return 0;
}
//Output:
//Popping out elements... 4 3 2 1 0

6.stack::swap
交換內容，用x的內容交換容器介面卡（* this）的內容。該成員函式呼叫非成員函式swap（unqualified）來交換基礎容器。noexcept說明符匹配底層容器上的交換操作。

// stack::swap
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> foo,bar;
  foo.push (10); foo.push(20); foo.push(30);
  bar.push (111); bar.push(222);

  foo.swap(bar);

  std::cout << "size of foo: " << foo.size() << '\n';
  std::cout << "size of bar: " << bar.size() << '\n';

  return 0;
}
//Output:
//size of foo: 2
//size of bar: 3