复习一下数据结构，用链表实现了一个堆栈模板类。
写的过程中用到一些知识点，碰到一些问题，随手记下来。

1：mystack<int> s; mystack<int> s2 = s;
编译器会把s2 = s编译成拷贝构造函数s2(s)，此时调用的是拷贝构造函数，而不是赋值函数(切记)。
另外有时候编译器这种自做聪明，自动调用符合参数类型的构造函数会带来很难发现的错误，为了防止编译器这么做，可以在构造函数声明前加explicit关键字。

2：不改变成员变量值的函数，例如empty()，要声明为const,这点很重要，不然当一个const mystack&类型的对象调用empty()的时候，会编不过。

3：拷贝构造函数最好要先判断是否是拷贝自身，不然有时候就出错。

4：拷贝构造函数也别忘了成员变量初始化列表。 

template<typename T>
class mystack
{
public:
    mystack();
    mystack(const mystack& src);
    ~mystack();
    bool push(const T& data);
    T pop();
    bool empty() const;
    void clear();
    mystack& operator = (const mystack& src);
private:
    void copystack(mystack& dst, const mystack& src);
    struct stacknode
    {
        T data;
        stacknode* pnext;
    };
    stacknode* phead;
};

template<typename T>
mystack<T>::mystack():phead(NULL)
{}

template<typename T>
mystack<T>::mystack(const mystack<T>& src):
phead(NULL)
{
    copystack(*this, src);
}

template<typename T>
mystack<T>::~mystack()
{
    clear();
}

template<typename T>
void mystack<T>::clear()
{
    while(!empty())
    {
        pop();
    }
}

template<typename T>
void mystack<T>::copystack(mystack& dst, const mystack& src)
{
    stacknode* p = src.phead;
    mystack<T> tmp;
    while(p)
    {
        tmp.push(p->data);
        p = p->pnext;
    }
    while(!tmp.empty())
    {
        dst.push(tmp.pop());
    }
}

template<typename T>
mystack<T>& mystack<T>::operator=(const mystack& src)
{
    if (this == &src)
        return *this;
    clear();
    copystack(*this, src);
    return *this;
}

template<typename T>
bool mystack<T>::empty() const 
{
    return(phead == NULL);
}

template<typename T>
bool mystack<T>::push(const T& data)
{
    stacknode* p = new stacknode;
    if (!p) return false;
    p->data = data;
    p->pnext = phead;
    phead = p;
    return true;
}

template<typename T>
T mystack<T>::pop()
{
    assert(!empty());
    T data;
    data = phead->data;
    stacknode* tmp = phead;
    phead = phead->pnext;
    delete tmp;
    return data;
}

int main(int argc, char* argv[])
{
    mystack<int> s;    
    for (int i = 0; i < 1000; i++)
        s.push(rand());
    mystack<int> s2(s);
    while(!s2.empty())
    {
        cout<<s2.pop()<<endl;
    }
    return 0;
}