DAY6，C++（将顺序栈，顺序循环队列定义成模板类）；

1.将顺序栈定义成模板类；​​​​​​

顺序栈模板代码--- 

#include 

using namespace std;

template
class Stack
{
private:
    T *data;  //指向堆区空间
    int top;  //记录栈顶位置

public:
    Stack();  //无参构造
    Stack(T size);  //有参构造
    ~Stack();  //析构函数
    bool Empty();  //判空
    bool Full(T size);  //判满
    T get_elemsize();  //返回容纳的元素数
    void Push(T size,T elem);  //入栈
    void Pop();  //出栈
    void Output();  //遍历栈内元素
    T get_top();  //访问栈顶元素

    //重载=运算符（一个Stack对象赋值给另一个Stack对象）
    Stack &operator =(const Stack &R)
    {
        if(this == &R)
            return *this;

        delete [] data;
        data = new T[R.top+1];

        for(int i=0; i<=R.top; i++)
            data[i] = R.data[i];
        top = R.top;

        return *this;
    }

};

//无参构造
template
Stack::Stack():data(new T[10]),top(-1) {}

//有参构造
template
Stack::Stack(T size):data(new T[size]),top(-1) {}

//析构函数
template
Stack::~Stack() {delete [] data;}

//判空
template
bool Stack:: Empty()
{
    return top==-1;
}

//判满
template
bool Stack:: Full(T size)
{
    return top==size-1;
}

//返回容纳的元素数
template
T Stack::get_elemsize()
{
    return top+1;
}

//入栈
template
void Stack::Push(T size,T elem)
{
    if(Full(size) == true)
        return;
    data[++top] = elem;
}

//出栈
template
void Stack::Pop()
{
    if(Empty() == true)
        return;
    top--;
}

//遍历栈内元素
template
void Stack::Output()
{
    if(Empty() == true)
        return;
    for(int i=0; i<=top; i++)
    {
        cout<
T Stack::get_top()
{
    if(Empty() == true)
        return 0;
    return data[top];
}


int main()
{
    int size;
    cout<<"输入栈的大小>>> ";
    cin>>size;

    Stack s1(size);  //有参构造

    char ch;
    int elem;
    do         //入栈
    {
        cout<<"输入入栈元素>>> ";
        cin>>elem;
        s1.Push(size,elem);

        if(s1.Full(size) == true)
        {
            cout<<"栈满，退出入栈"<>ch;
    }while(ch == 'y' || ch =='Y');

    s1.Output();  //遍历

    s1.Pop();  //弹出栈顶元素
    cout<<"弹出栈顶元素后>>> ";
    s1.Output();  //遍历

    cout<<"容纳的元素数>>> "<>> "< s2;
    s2 = s1;       //重载=
    cout<<"赋值后s2>>> ";
    s2.Output();  //遍历s2

    return 0;
}

 

2.将循环顺序队列定义成模板类；

循环顺序队列模板代码---

#include 

using namespace std;

#define MAXSIZE 6

template
class Queue
{
private:
    T *data;  //指向堆区空间
    int front;  //记录队头
    int rear;  //记录队尾

public:
    Queue();  //无参构造
    Queue(T size);  //有参构造
    ~Queue();  //析构函数
    bool Empty();  //判空
    bool Full(T size);  //判满
    T get_elemsize(T size);  //返回容纳的元素数
    void Push(T size,T elem);  //入队
    void Pop(T size);
    void Output(T size);  //遍历队内元素
    T get_firstelem();  //访问第一个元素
    T get_endelem();  //访问最后一个元素

    //重载=运算符（一个Queue对象赋值给另一个Queue对象）
    Queue &operator =(const Queue &R)
    {
        if(this == &R)
            return *this;

        delete [] data;
        data = new T[MAXSIZE];

        for(int i=front; i != R.rear; i=(i+1)%MAXSIZE)
            data[i] = R.data[i];
        front = R.front;
        rear = R.rear;

        return *this;
    }

};

template
Queue::Queue():data(new T[MAXSIZE]),front(0),rear(0) {}  //无参构造

template
Queue::Queue(T size):data(new T[size]),front(0),rear(0) {}  //有参构造

template
Queue::~Queue() {delete [] data;}  //析构函数

template
bool Queue::Empty()  //判空
{
    return front==rear;
}

template
bool Queue::Full(T size)  //判满
{
    return front == (rear+1)%size;
}

template
T Queue::get_elemsize(T size)  //返回容纳的元素数
{
    return (size-front+rear)%size;
}

template
void Queue::Push(T size,T elem)  //入队
{
    if(Full(size) == true)
        return;
    data[rear] =  elem;
    rear = (rear+1)%size;
}

template
void Queue::Pop(T size)          //出队
{
    if(Empty() == true)
        return;
    front = (front+1)%size;
}

template
void Queue::Output(T size)   //遍历队内元素
{
    if(Empty() == true)
        return;
    for(int i=front; i != rear; i=(i+1)%size)
    {
        cout<
T Queue::get_firstelem()
{
    return data[front];
}

//访问最后一个元素
template
T Queue::get_endelem()
{
    return data[rear-1];
}

int main()
{

    int size;
    cout<<"输入队列的大小>>> ";
    cin>>size;

    Queue s1(size);  //有参构造

    char ch;
    int elem;
    do         //入队
    {
        cout<<"输入入队元素>>> ";
        cin>>elem;
        s1.Push(size,elem);

        if(s1.Full(size) == true)
        {
            cout<<"队满，退出入队"<>ch;
    }while(ch == 'y' || ch =='Y');

    s1.Output(size);  //遍历

    s1.Pop(size);  //弹出队尾元素
    cout<<"弹出一个队尾元素后>>> ";
    s1.Output(size);  //遍历

    cout<<"容纳的元素数>>> "<>> "<>> "< s2;
    s2 = s1;       //重载=
    cout<<"赋值后s2>>> ";
    s2.Output(size);  //遍历s2


    return 0;
}

 

3.今日c++知识脑图；