7.21 C++

栈的模板类

#include 
#include 

using namespace std;
#define MAXSIZE 20  //栈的大小
#define Elemtype char

template
class Stack
{
protected:
    T *str;  //执行堆区空间
    int top;  //记录栈顶元素的位置
public:
    Stack():str(new T[MAXSIZE-1]),top(-1){}   //无参构造
    Stack(int size):str(new T[size]),top(-1){}  //有参构造
    ~Stack(){}  //析构函数
    Stack &operator=(const Stack &other)  //拷贝赋值函数
    {
        this->top=other.top;
        delete []str;
        this->str=new T;
        for(int i=0;i<=top;i++)
        {
            str[i]=other.str[i];
        }
        return *this;
    }
    T Top();  //类内声明，返回栈顶元素
    bool Empty();  //类内声明，判断是否栈空
    bool Full();  //类内声明，判断是否栈满
    int Size();  //类内声明，返回容纳的元素数
    void Push(T &elem);  //类内声明，入栈操作
    void Pop();  //类内声明，出栈操作
    void Output();  //类内声明，遍历栈内元素
};

//类外定义，判断是否栈空
template 
bool Stack::Empty()  //<>为类型，这样是显性定义
{
    if(top==-1)
        return true;
    return false;
}
//类外定义，返回栈顶元素
template 
T Stack::Top()
{
    if(Empty())
        return false;
    return *(str+top);
}
//类外定义，判断是否栈满
template 
bool Stack::Full()
{
    if(top=MAXSIZE-1)
        return true;
}
//类外定义，返回容纳的元素数
template 
int Stack::Size()
{
    return top+1;
}
//类外定义，入栈操作
template 
void Stack::Push(T &elem)
{
    if(Full())
        cout<<"栈满，入栈失败！"<
void Stack::Pop()
{
    if(Empty())
        cout<<"栈空，出栈失败！"<
void Stack::Output()
{
    if(Empty())
        cout<<"栈空，无元素输出！"< s;  //无参构造，显性定义

    char ch;
    Elemtype elem=0; //存储入栈元素，初始化为0

    //循环入栈
    do{
        if(s.Full())  //栈满就结束
            break;
        cout<<"请输入入栈元素："<>elem;
        s.Push(elem);
        cout<<"是否继续入栈？(Y/N)"<>ch;
    }while(ch=='y'||ch=='Y');

    //循环出栈
    do
    {
        if(s.Empty())  //栈空就结束
            break;
        Pop();
        cout<<"是否继续出栈？(Y/N)"<>ch;
    }while(ch=='y'||ch=='Y');

    cout<<"栈顶元素为："<>size;
    Stack m(size);  //有参构造
    m=s;  //拷贝赋值
    m.Output();

    return 0;
}

循环队列的模板类

#include 
#include 

using namespace std;
#define MAXSIZE 20  //栈的大小
#define Elemtype char

template
class Queue
{
protected:
    T *str;  //执行堆区空间
    int front;  //记录对头元素的位置
    int rear;  //记录对尾元素的位置
public:
    Queue():str(new T[MAXSIZE-1]),front(0),rear(0){}   //无参构造
    ~Queue(){}  //析构函数
    Queue &operator=(const Queue &other)  //拷贝赋值函数
    {
        this->front=other.front;
        this->rear=other.rear;
        delete []str;
        this->str=new T;
        for(int i=0;i<=rear;i++)
        {
            str[i]=other.str[i];
        }
        return *this;
    }
    T Top();  //类内声明，返回队头元素
    bool Empty();  //类内声明，判断是否队空
    bool Full();  //类内声明，判断是否队满
    int Size();  //类内声明，返回容纳的元素数
    void Enqueue(T &elem);  //类内声明，入队操作
    void Dequeue();  //类内声明，出队操作
    void Output();  //类内声明，遍历队内元素
};

//类外定义，判断是否队空
template 
bool Queue::Empty()  //<>为类型，这样是显性定义
{
    if(front==rear)
        return true;
    return false;
}
//类外定义，返回队头元素
template 
T Queue::Top()
{
    if(Empty())
        return false;
    return *(str+front);
}
//类外定义，判断是否队满
template 
bool Queue::Full()
{
    if(front==(rear+1)%MAXSIZE)
        return true;
}
//类外定义，返回容纳的元素数
template 
int Queue::Size()
{
    return (MAXSIZE+rear-front)%MAXSIZE;
}
//类外定义，入队操作
template 
void Queue::Enqueue(T &elem)
{
    if(Full())
        cout<<"队满，入队失败！"<
void Queue::Dequeue()
{
    if(Empty())
        cout<<"队空，出队失败！"<
void Queue::Output()
{
    if(Empty())
        cout<<"栈空，无元素输出！"< q;  //无参构造，显性定义

    char ch;
    Elemtype elem=0; //存储入队元素，初始化为0

    //循环入队
    do{
        if(q.Full())  //队满就结束
            break;
        cout<<"请输入入队元素："<>elem;
        q.Enqueue(elem);
        cout<<"是否继续入队？(Y/N)"<>ch;
    }while(ch=='y'||ch=='Y');

    //循环出队
    do
    {
        if(q.Empty())  //队空就结束
            break;
        q.Dequeue();
        cout<<"是否继续出队？(Y/N)"<>ch;
    }while(ch=='y'||ch=='Y');

    cout<<"队头元素为："< m;
    m=q;  //拷贝赋值函数
    q.Output();

    return 0;
}

思维导图