C++day6

将之前定义的栈类和队列类都实现成模板类

栈类

#include 

#define max 32

using namespace std;
template
class Stack
{
private:
    T data[max];
    T top;
public:
    Stack();
    Stack(T t);
    ~Stack();
    Stack(Stack &s);
    bool stack_empty();
    bool stack_full();
    T stack_push(T e);
    T stack_pop();
    T stack_top();
    T stack_size();
    void stack_clear();
};

int main()
{

    Stack s(-1);
    s.stack_push(1);
    s.stack_push(2);
    s.stack_push(3);
    s.stack_push(4);
    s.stack_size();
    s.stack_top();
    s.stack_pop();
    s.stack_pop();
    s.stack_pop();
    s.stack_pop();
    s.stack_size();
    s.stack_top();
    s.stack_clear();
    return 0;
}

template 
Stack::Stack()
{
    cout<<"Stack:无参构造函数"<
Stack::Stack(T t):top(t)
{
    cout<<"Stack:有参构造函数"<
Stack::~Stack()
{
    cout<<"Stack:析构函数"<
Stack::Stack(Stack &s):top(s.top)
{
    for(int i=0;i
bool Stack::stack_empty()
{
    if(-1==top)
        return true;
    else
        return false;
}
template 
bool Stack::stack_full()
{
    if(max-1==top)
        return true;
    else
        return false;
}
template 
T Stack::stack_push(T e)
{
    top++;
    data[top]=e;
    cout<
T Stack::stack_pop()
{
    T e=data[top];
    top--;
    cout<
T Stack::stack_top()
{
    T e=data[top];
    cout<<"栈顶元素为："<
T Stack::stack_size()
{
    cout<<"栈的大小为："<
void Stack::stack_clear()
{
    top=-1;
    cout<<"栈已清空"<

队列类

#include 
using namespace std;
#define max 32

template 
class Queue
{
private:
    T data[max];
    T front;
    T tail;
public:
    Queue();
    Queue(T f,T t);
    ~Queue();
    Queue(Queue &q);
    bool queue_empty();
    bool queue_full();
    T queue_push(T e);
    T queue_pop();
    T queue_size();
    void queue_clear();


};
int main()
{
    Queue q(0,0);
    q.queue_push(1);
    q.queue_push(2);
    q.queue_push(3);
    q.queue_push(4);
    q.queue_size();
    q.queue_pop();
    q.queue_pop();
    q.queue_pop();
    q.queue_pop();
    q.queue_size();
    q.queue_clear();
    return 0;
}

template 
Queue::Queue()
{
    cout<<"Queue:无参构造函数"<
Queue::Queue(T f,T t):front(f),tail(t)
{
    cout<<"Queue:有参构造函数"<
Queue::~Queue()
{
    cout<<"Queue:析构函数"<
Queue::Queue(Queue &q):front(q.front),tail(q.tail)
{
    while(front!=tail){
        data[front]=q.data[front];
        front=(front+1)%max;
    }
}
template 
bool Queue::queue_empty()
{
    if(front==tail)
        return true;
    else
        return false;
}
template 
bool Queue::queue_full()
{
    if((tail+1)%max==front)
        return true;
    else
        return false;
}
template 
T Queue::queue_push(T e)
{
    if(Queue::queue_full()){
        cout<<"入队失败"<
T Queue::queue_pop()
{
    if(Queue::queue_empty()){
        cout<<"出队失败"<
T Queue::queue_size()
{
    T size=(tail-front+max)%max;
    cout<<"队长为："<
void Queue::queue_clear()
{
    front=tail;
    cout<<"清空队列"<

思维导图