棧是一種特殊的線性表，

線性表是具有相同型別的n(n>=0)個數據元素的有序(中間不能空位置)有限序列。

  對棧的操作（增/刪/讀）只能通過棧的一端進行，允許操作的一端稱之為棧頂，不允許操作的一端稱為棧底。棧的特性為先進後出。c++實現棧，可採用如下的設計思路：

  Stack是一個介面類，封裝了棧的所有操作：

//Stack.h
#ifndef __STACK_H__
#define __STACK_H__

#include <exception>

template<typename T>
class Stack
{
public:
    virtual
 
 void push(const T& e) = 0;   //入棧
    virtual void pop() = 0;                     //出棧
    virtual T top() const = 0;                  //讀棧頂元素
    virtual void clear() = 0;                      //清空棧
    virtual int size() const = 0;                  //獲取棧元素的個數
};
#endif

  陣列實現的棧空間：

//StaticStack.h
#ifndef __STATICSTACK_H__
 

#define __STATICSTACK_H__

#include "Stack.h"

template <typename T, int N>
class StaticStack : public Stack<T>
{
protected:
    T m_space[N];
    int m_top;      //標誌棧頂元素所在下標
    int m_size;     //標誌棧空間中有多少個元素

public:
    StaticStack()
    {
        m_top = -1;
        m_size = 0;
    }

    int
 
 capacity() const
    {
        return N;
    }

    void push(const T& e)
    {
        if (m_size < N)
        {
            m_space[m_top + 1] = e;
            ++m_top;
            ++m_size;
        }
        else
            throw(std::out_of_range("StaticStack::push() out of randge"));  
    }

    void pop()
    {
        if (m_size > 0)
        {
            --m_top;
            --m_size;
        }
        else
            throw(std::runtime_error("No element in current stack"));
    }

    T top() const
    {
        if (!(m_size > 0))
        {
            std::runtime_error("No element in current stack");
        }

        return m_space[m_top];
    }

    void clear()
    {
        m_top = -1;
        m_size = 0;
    }

    int size() const
    {
        return m_size;
    }
};

#endif /* __STATICSTACK_H__ */

  使用者要使用StaticStack生成棧資料結構時，需要指定通過泛型引數N傳入陣列的大小：

//main.cpp
int main()
{
    for (int i = 0; i < 5; ++i)
    {
        stack.push(i);
    }

    while (stack.size() > 0)
    {
        std::cout << stack.top() << std::endl;
        stack.pop();
    }

    getchar();
    return 0;
}

  StaticStack存在的缺陷是如果儲存的元素為類型別，那麼在建立StaticStack的物件時將會多次呼叫元素型別的建構函式，顯然，這十分影響效率，甚至多做一些無用功。改進方法可以是用單向連結串列來生成棧空間：

//LinkStack.h
#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__

#include "LinkStack.h"
#include "LinkList.h"

template<typename T>
class LinkStack : public Stack<T>
{
protected:
    LinkList<T> m_list;

public:
    void push(const T& e)
    {
        m_list.insert(0, e);
    }

    void pop()
    {
        if (m_list.length() > 0)
        {
            m_list.remove(0);
        }
        else
            throw(std::runtime_error("No element in current stack"));
    }

    T top() const
    {
        if (m_list.length() > 0)
            return m_list.get(0);
        else
            throw(std::runtime_error("No element in current stack"));
    }

    void clear()
    {
        m_list.clear();
    }

    int size() const
    {
        return m_list.length();
    }
};

#endif /* __LINKSTACK_H__ */