用模板完成顺序栈和顺序队列

顺序栈 

#include 
using namespace std;
#define MAX 50
 
template<typename T>
class Stack
{
private:
    T *data;
    int top;
public:
    Stack():data(new T[MAX]),top(-1)
    {
        cout<<"Stack::无参构造函数"<
    }
    ~Stack()
    {
        delete []data;
        cout<<"Stack::构析函数"<
    }
    Stack(const Stack &other)
    {
        if(data!=NULL)
        {
            delete[]data;
        }
        this->data=new T[MAX];
        memcpy(this->data,other.data,sizeof(T)*MAX);
        this->top=other.top;
        cout<<"Stack::拷贝构造函数"<
    }
    void stack_push(T &&val);
    void stack_pop();
    void stack_clear();
    bool stack_empty();
    bool stack_full();
    T stack_gettop();
    int stack_len();
    void stack_show();
};
template<typename T>
void Stack::stack_push(T &&val)
{
    this->top++;
    this->data[top]=val;
}
 
template<typename T>
void Stack::stack_pop()
{
    if(NULL==this->data || stack_empty())
    {
        cout<<"所给顺序栈不合法"<
    }
    cout<<this->data[top]<<"出栈成功"<
    this->top--;
}
 
template<typename T>
void Stack::stack_clear()
{
    this->top=-1;
}
 
template<typename T>
bool Stack::stack_empty()
{
    return -1==this->top;
}
 
template<typename T>
bool Stack::stack_full()
{
    return MAX-1==this->top;
}
 
template<typename T>
T Stack::stack_gettop()
{
    return this->data[top];
}
 
template<typename T>
int Stack::stack_len()
{
    return this->top+1;
}
 
template<typename T>
void Stack::stack_show()
{
    for(int i=top;i>=0;i--)
    {
        cout<<this->data[i]<<" ";
    }
    cout<
}

顺序队列

 
#include 
 
#define MAX 50
using namespace std;
 
template<typename T>
class Queue
{
private:
    T *data;
    T head;
    T tail;
 
public:
    Queue():data(new T[MAX]),head((T)0),tail((T)0)
    {
        cout<<"queue::无参构造函数"<
    }
    ~Queue()
    {
        delete []data;
        cout<<"queue::析构函数"<
    }
    Queue(const Queue &other):
        data(new T(*other.data)),
        head(other.head),
        tail(other.tail)
    {
        this->data=new T[MAX];
        memcpy(this->data,other.data,sizeof(T)*MAX);
        this->head=other.head;
        this->tail=other.tail;
        cout<<"拷贝构造函数"<
    }
    void queue_push(T &&val);
    void queue_pop();
    void queue_clear();
    bool queue_empty();
    bool queue_full();
    int queue_len();
    void queue_show();
};
template<typename T>
void Queue::queue_push(T &&val)
{
    data[tail]=val;
    tail=(tail+1)%MAX;
    return;
}
template<typename T>
void Queue::queue_pop()
{
    cout<"出队成功"<
    head=(head+1)%MAX;
    return;
}
template<typename T>
void Queue::queue_clear()
{
    while(!queue_empty())
    {
        queue_pop();
    }
}
template<typename T>
bool Queue::queue_empty()
{
    return head==tail;
}
template<typename T>
bool Queue::queue_full()
{
    return head==(tail+MAX)%MAX;
}
template<typename T>
int Queue::queue_len()
{
    return (tail+MAX-head)%MAX;
}
template<typename T>
void Queue::queue_show()
{
    for(int i=head;i!=tail;i=(i+1)%MAX)
    {
        cout<" ";
    }
    cout<
}