容器介面卡是一個封裝了序列容器的類模板，它在一般序列容器的基礎上提供了一些不同的功能。之所以稱作介面卡類，是因為它可以通過適配容器現有的介面來提供不同的功能。

stack容器介面卡中的資料是以 LIFO 的方式組織的，這和自助餐館中堆疊的盤子、箱子中的一堆書類似。圖 1 展示了一個理論上的 stack 容器及其一些基本操作。只能訪問 stack 頂部的元素；只有在移除 stack 頂部的元素後，才能訪問下方的元素。

stack 容器有廣泛的應用。例如，編輯器中的 undo (撤銷)機制就是用堆疊來記錄連續的變化。撤銷操作可以取消最後一個操作，這也是發生在堆疊頂部的操作。編譯器使用堆疊來解析算術表示式，當然也可以用堆疊來記錄 C++ 程式碼的函式呼叫。下面展示瞭如何定義一個用來存放字串物件的 stack 容器：

std::stack<std::string> words;

stack 容器介面卡的模板有兩個引數。第一個引數是儲存物件的型別，第二個引數是底層容器的型別。 stack 的底層容器預設是 deque 容器，因此模板型別其實是 stack<typename T, typename Container=deque>。通過指定第二個模板型別引數，可以使用任意型別的底層容器，只要它們支援 back()、push_back()、pop_back()、empty()、size() 這些操作。下面展示瞭如何定義一個使用 list 的堆疊：

std::stack<std::string,std::list<std::string>> fruit;
 

建立堆疊時，不能在初始化列表中用物件來初始化，但是可以用另一個容器來初始化，只要堆疊的底層容器型別和這個容器的型別相同。例如：

std::list<double> values {1.414, 3.14159265, 2.71828};
std::stack<double,std::list<double>> my_stack (values);

第二條語句生成了一個包含 value 元素副本的 my_stack。這裡不能在 stack 建構函式中使用初始化列表；必須使用圓括號。如果沒有在第二個 stack 模板型別引數中將底層容器指定為 list，那麼底層容器可能是 deque，這樣就不能用 list 的內容來初始化 stack；只能接受 deque。

stack 模板定義了拷貝建構函式，因而可以複製現有的 stack 容器：

std::stack<double,std::list<double>>copy_stack {my_stack}

copy_stack 是 my_stack 的副本。如你所見，在使用拷貝建構函式時，既可以用初始化列表，也可以用圓括號。

堆疊操作

和其他序列容器相比，stack 是一類儲存機制簡單、所提供操作較少的容器。下面是 stack 容器可以提供的一套完整操作：

top()：返回一個棧頂元素的引用，型別為 T&。如果棧為空，返回值未定義。
push(const T&obj)：可以將物件副本壓入棧頂。這是通過呼叫底層容器的 push_back() 函式完成的。
push(T&&obj)：以移動物件的方式將物件壓入棧頂。這是通過呼叫底層容器的有右值引用引數的 push_back() 函式完成的。
pop()：彈出棧頂元素。
size()：返回棧中元素的個數。
empty()：在棧中沒有元素的情況下返回 true。
emplace()：用傳入的引數呼叫建構函式，在棧頂生成物件。
swap(stack< T> &other_stack)：將當前棧中的元素和引數中的元素交換。引數所包含元素的型別必須和當前棧的相同。對於 stack物件有一個特例化的全域性函式 swap() 可以使用。

stack 模板也定義了複製和移動版的 operator=() 函式，因此可以將一個 stack 物件賦值給另一個 stack 物件。stack 物件有一整套比較運算子。比較運算通過字典的方式來比較底層容器中相應的元素。字典比較是一種用來對字典中的單詞進行排序的方式。依次比較對應元素的值，直到遇到兩個不相等的元素。第一個不匹配的元素會作為字典比較的結果。如果一個 stack 的元素比另一個 stack 的多，但是所匹配的元素都相等，那麼元素多的那個 stack 容器大於元素少的 stack 容器。

我們可以用 stack 容器來實現一個簡單的計算器程式。這個程式支援一些基本的加、 減、乘、除、冪操作。它們分別對應運算子 +、-、*、/、^ 。冪操作由定義在標頭檔案 cmath 中的 pow() 函式提供。表示式以單行字串的形式讀入，可以包含空格。在解析字串之前可以使用 remove() 演算法來移除輸入表示式中的空格，然後再執行這個表示式所包含的運算。下面我們會定義一個函式來獲取運算子的優先順序：

inline size_t precedence(const char op)
{
    if (op == '+' || op ==' - ')
        return 1;
    if (op == '*' || op == ' / ')
        return 2;
    if (op =='^')
        return 3;
    throw std:: runtime_error {string{"invalid operator: "} + op};
}

+和 - 的優先順序最低，其次是 * 和 /，最後是 ^。運算子的優先順序決定了它們在表示式中的執行順序。如果引數是一個不支援的運算子，那麼會丟擲一個 runtime_error 異常物件。異常物件建構函式中的字串引數，可以在 catch 程式碼塊中通過呼叫物件的 what() 函式獲得。

這個程式通過從左到右掃描的方式來分析輸入表示式，並且會將運算子儲存到 stack 容器 operators 中。運算元存放在 stack 容器 operands 中。所有的運算子都需要兩個運算元，所以每執行一次運算，都需要獲取一個 operators 棧頂的運算子，以及兩個 operands 棧頂的運算元。運算由下面的函式執行：

double execute(std::stack<char>& ops, std::stack<double>& operands)
{
    double result {};
    double rhs {operands.top()};                            // Get rhs...
    operands.pop();                                         // ...and delete from stack
    double lhs {operands.top()};                            // Get lhs...
    operands.pop();                                         // ...and delete from stack
    switch (ops.top())                                      // Execute current op
    {
        case '+':
            result = lhs + rhs;
            break;
        case '-':
            result = lhs - rhs;
            break;
        case '*':
            result = lhs * rhs;
            break;
        case '/':
            result = lhs / rhs;
            break;
        case '^':
            result = std::pow(lhs, rhs);
            break;
        default:
            throw std::runtime_error {string{"invalid operator: "} + ops.top()};
    }
    ops.pop(); // Delete op just executed
    operands.push(result);
    return result;
}

函式的引數是兩個 stack 容器的引用。可以用 operands 容器的 top() 函式獲取運算元。 top() 函式只能得到棧頂元素；為了訪問下一個元素，必須通過呼叫 pop() 來移除當前棧頂元素。

注意，棧中運算元的順序是相反的，因此得到的第一個運算元是運算的右運算元。operators 容器頂部的元素用來在 switch 中選擇運算。在它不匹配任何一個 case 分支時，會丟擲一個異常來表明這個運算子是無效的。

下面是這個程式的完整程式碼：

// A simple calculator using stack containers
#include <cmath>                                          // For pow() function
#include <iostream>                                       // For standard streams
#include <stack>                                          // For stack<T> container
#include <algorithm>                                      // For remove()
#include <stdexcept>                                      // For runtime_error exception
#include <string>                                         // For string class
using std::string;
// Returns value for operator precedence
inline size_t precedence(const char op)
{
    if (op == '+' || op == '-')
        return 1;
    if (op == '*' || op == '/')
        return 2;
    if (op == '^')
        return 3;
    throw std::runtime_error {string {"invalid operator in precedence() function: "} + op};
}
// Execute an operation
double execute(std::stack<char>& ops, std::stack<double>& operands)
{
    double result {};
    double rhs {operands.top()};                            // Get rhs...
    operands.pop();                                         // ...and delete from stack
    double lhs {operands.top()};                            // Get lhs...
    operands.pop();                                         // ...and delete from stack
    switch (ops.top())                                      // Execute current op
    {
        case '+':
            result = lhs + rhs;
            break;
        case '-':
            result = lhs - rhs;
            break;
        case '*':
            result = lhs * rhs;
            break;
        case '/':
            result = lhs / rhs;
            break;
        case '^':
            result = std::pow(lhs, rhs);
            break;
        default:
            throw std::runtime_error {string{"invalid operator: "} + ops.top()};
    }
    ops.pop();                                              // Delete op just executed
    operands.push(result);
    return result;
}
int main()
{
    std::stack<double> operands;                            // Push-down stack of operands
    std::stack<char> operators;                             // Push-down stack of operators
    string exp;                                             // Expression to be evaluated
    std::cout << "An arithmetic expression can include the operators +, -, *, /, and ^ for exponentiation." << std::endl;
    try
    {
        while (true)
        {
            std::cout << "Enter an arithmetic expression and press Enter - enter an empty line to end:" << std::endl;
            std::getline(std::cin, exp, '\n');
            if (exp.empty()) break;
            // Remove spaces
            exp.erase(std::remove(std::begin(exp), std::end(exp), ' '), std::end(exp));
            size_t index {};                                    // Index to expression string
            // Every expression must start with a numerical operand
            operands.push(std::stod(exp, &index));              // Push the first (lhs) operand on the stack
            while (true)
            {
                operators.push(exp[index++]);                     // Push the operator on to the stack
                // Get rhs operand
                size_t i {};                                      // Index to substring
                operands.push(std::stod(exp.substr(index), &i));  // Push rhs operand
                index += i;                                       // Increment expression index
                if (index == exp.length())                        // If we are at end of exp...
                {
                    while (!operators.empty())                      // ...execute outstanding ops
                        execute(operators, operands);
                    break;
                }
                // If we reach here, there's another op...
                // If there's a previous op of equal or higher precedence execute it
                while (!operators.empty() && precedence(exp[index]) <= precedence(operators.top()))
                    execute(operators, operands);                   //  Execute previous op.
            }
            std::cout << "result = " << operands.top() << std::endl;
        }
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
    std::cout << "Calculator ending..." << std::endl;
}

while 迴圈包含在一個 try 程式碼塊中，這樣就可以捕獲丟擲的任何異常。在 catch 程式碼塊中，呼叫異常物件的成員函式 what() 會將錯誤資訊輸出到標準錯誤流中。在一個死迴圈中執行輸入操作，當輸入一個空字串時，迴圈結束。可以使用 remove() 演算法消除非空字串中的空格。remove() 不能移除元素，而只能通過移動元素的方式來覆蓋要移除的元素。

為了移除 exp 字串中剩下的多餘元素，可以用兩個迭代器作為引數呼叫 erase()。其中第一個迭代器由 remove() 返回，指向字串的最後一個有效元素的後面位置。第二個迭代器是字串原始狀態的結束迭代器。這兩個迭代器指定範圍的元素會被刪除。

每個浮點運算元的值都是用定義在標頭檔案 string 中的 stod() 函式獲取的。這會將第一個字串引數中的字元序列轉換為 double 值。函式會從第一個表示有效浮點數的字串的第一個字元開始，獲取最長字元序列。第二個引數是一個整型指標，儲存的是字串中非數字部分第一個字元的索引。string 標頭檔案中定義了 stod() 函式，它可以返回一個 float 值。 Stod() 會返回一個 long double 值。

因為所有的運算子都需要兩個運算元，所以有效的輸入字串格式總是為 operand op operand op operand，等等。序列的第一個和最後一個元素都是運算元，每對運算元之間有一個運算子。因為有效表示式總是以運算元開頭，所以第一個運算元在分析表示式的巢狀迴圈之前被提取出來。在迴圈中，輸入字串的運算子會被壓入 operators 棧。在確認沒有到達字串末尾後，再從 exp 提取第二個運算元。這時，stod() 的第一個引數是從 index 開始的 exp 字串，它是被壓入 operators 棧的運算子後的字元。非數字字串的第一個索引儲存在i中。因為 i 是相對於 index 的，所以我們會將 index 加上 i 的值，使它指向運算元後的一個運算子(如果是 exp 中的最後一個運算元，它會指向字串末尾的下一個位置)。

當 index 的值超過 exp 的最後一個字元時，會執行 operators 容器中剩下的運算子。如果沒有到達字串末尾，operators 容器也不為空，我們會比較 operators 棧頂運算子和 exp 中下一個運算子的優先順序。如果棧頂運算子的優先順序高於下一個運算子，就先執行棧頂的運算子。否則，就不執行棧頂運算子，在下一次迴圈開始時，將下一個運算子壓入 operators 棧。通過這種方式，就可以正確計算出帶優先順序的表示式的值。

下面是一些示例輸出：

An arithmetic expression can include the operators +, -, *, /, and ^ for exponentiation.
Enter an arithmetic expression and press Enter - enter an empty line to end:
2^0.5
result = 1.41421
Enter an arithmetic expression and press Enter - enter an empty line to end:
2.5e2 + 1.5e1*4
result = 310
Enter an arithmetic expression and press Enter - enter an empty line to end:
3*4*5 + 4*5*6 + 5*6*7
result = 390
Enter an arithmetic expression and press Enter - enter an empty line to end:

Calculator ending...

程式輸出表明計算器工作正常，也說明 stod() 函式可以將不同符號的字串轉換為數字。