数据结构学习记录之栈篇（动态数组模拟栈）

/**
 * 动态数组实现栈模板类
 * **/

#include <iostream>

#define ssize_t unsigned int

template<class T>
class DStack
{
private:
    ssize_t myCapacity;
    ssize_t mySize;
    T* myArray;

public:
    DStack(ssize_t capacity=1024);
    DStack(const DStack<T>& orignial);
    DStack<T>& operator=(const DStack<T>& rightHandSide);
    ~DStack();

    ssize_t capacity() const;
    ssize_t size() const;
    bool empty() const;
    void push(T value);
    void pop();
    T top() const;

    void display() const;
};

template<class T>
DStack<T>& DStack<T>::operator=(const DStack<T>& rightHandSide)
{
    if (this == &rightHandSide)
    {
        return *this;
    }
    if (myCapacity != rightHandSide.myCapacity)
    {
        delete [] myArray;
        myCapacity = rightHandSide.myCapacity;
        myArray = new T[myCapacity];
    }
    mySize = rightHandSide.mySize;
    for (ssize_t i = 0; i < rightHandSide.mySize; i++)
    {
        myArray[i] = rightHandSide.myArray[i];
    }
    return *this;
}

template<class T>
DStack<T>::DStack(const DStack<T>& orignial): myCapacity(orignial.myCapacity), mySize(orignial.mySize)
{
    myArray = new T[myCapacity];
    for (ssize_t i = 0; i < orignial.mySize; i++)
    {
        myArray[i] = orignial.myArray[i];
    }
}

template<class T>
T DStack<T>::top() const
{
    if (!empty())
    {
        return myArray[mySize-1];
    }
    std::cout << "Stack is full!" << std::endl;
    exit(1);
}

template<class T>
void DStack<T>::pop()
{
    if (!empty())
    {
        --mySize;
        return;
    }
    std::cout << "Stack is full!" << std::endl;
    exit(1);
}

template<class T>
bool DStack<T>::empty() const
{
    return mySize == 0;
}

template<class T>
void DStack<T>::display() const
{
    for (ssize_t i = 0; i < mySize; ++i)
    {
        std::cout << myArray[i] << " ";
    }
    std::cout << std::endl;
}

template<class T>
void DStack<T>::push(T value)
{
    if (mySize < myCapacity)
    {
        myArray[mySize] = value;
        ++mySize;
        return;
    }
    std::cout << "Stack is full!" << std::endl;
    exit(1);
}

template<class T>
ssize_t DStack<T>::size() const
{
    return mySize;
}

template<class T>
ssize_t DStack<T>::capacity() const
{
    return myCapacity;
}

template<class T>
DStack<T>::DStack(ssize_t capacity): myCapacity(capacity), mySize(0)
{
    myArray = new T[myCapacity];
}

template<class T>
DStack<T>::~DStack()
{
    delete [] myArray;
}