C++类模板

#if 0
//堆栈模板类
#include<list>
#include<iomanip>
template<typename T>
class Stack
{
    list<T> m_list;
public:
    Stack()
    {
        m_list.clear();
    }
    ~Stack()
    {
        m_list.clear();
    }
    Stack(Stack<T> const& that) :m_list(that.m_list) {}
    Stack<T>& operator=(Stack<T>const& that)
    {
        if (&that != this)
            m_list = that.m_list;
        return this;
    }
    void push(T const& data);
    void pop();
    T& top();
    T const& top()const;
    bool empty()const;
private:
    list<T> m_list;
};
//类模板中的所有非静态成员函数都是函数模板
template<typename T>//类外定义函数带上模板头
void Stack<T>::push(T const& data)
{
    m_list.push_front(data);
}
template<typename T>//类外定义函数带上模板头
void Stack<T>::pop()
{
    if (empty())
    {
        throw underflow_error("堆栈下溢");
    }
    m_list.pop_back();
}
template<typename T>//类外定义函数带上模板头
T& Stack<T>::top()
{
    if (empty())
    {
        throw underflow_error("堆栈下溢");
    }
    return m_list.back();
}
template<typename T>//类外定义函数带上模板头
T const& Stack<T>::top()const
{
    //return top();//return this->top(); this具有常属性 调用常函数
    return (Stack<T>)this->top();// const_cast<Stack<T>*>(this)-top;
}
template<typename T>//类外定义函数带上模板头
bool Stack<T>::empty()const
{
    return m_list.empty();
}
int main()
{
    try
    {
        Stack<int> s1;
        for (int i = 0; i < 10; ++i)
        {
            s1.push(i);
        }
        while (!s1.empty())
        {
            cout << setw(2) << left << s1.top() << endl;
            s1.pop();
        }
        cout << endl;
    }
    catch (exception& ex)
    {
        cout << ex.what() << endl;
        getchar();
        return -1;
    }
    return 0;
}
#endif // 类模板