C++ exercises 4

Write the constructor of the circular queue and the constructor and destructor of the chain queue, and complete the enqueue, dequeue, read the head element and empty detection operations of the two queues

main.cpp

#include<iostream>
#include "Linkqueue.h"
#include"CirQueue.h"
#include <string>
#include <sstream>
#include <exception>
int main()
{
    double x;
    string input;
    try
    {
    cout<<"----------链队列----------"<<endl;
    Linkqueue<double> linkqueue;
    while(true)
    {
        cout<<"请输入入队元素值（输入000退出）：";
        cin>>input;
        std::istringstream iss(input);
        if(!(iss >> x)) throw std::runtime_error("输入不是数");
        if(input=="000") break;
        linkqueue.EnQueue(x);
    }
    cout<<"当前队列元素为：";
    linkqueue.Printqueue();

    cout<<"出队操作，出队元素:"<<linkqueue.Dequeue();
    cout<<"  当前队列元素为：";
    linkqueue.Printqueue();

    cout<<"出队操作，出队元素:"<<linkqueue.Dequeue();
    cout<<"  当前队列元素为：";
    linkqueue.Printqueue();

    cout<<"队列是否为空：";
    if(linkqueue.Empty()) cout<<"是";
    else cout<<"否";
    cout<<endl;

    cout<<"----------循环队列----------"<<endl;
    CirQueue<double> cirqueue;
    while(true)
    {
        cout<<"请输入入栈元素值（输入000退出）：";
        cin>>input;
        std::istringstream iss(input);
        if(!(iss >> x)) throw std::runtime_error("输入不是数");
        if(input=="000") break;
        cirqueue.EnQueue(x);
    }
    cout<<"当前队列元素为：";
    cirqueue.PrintQueue();

    cout<<"出队操作，出队元素:"<<cirqueue.DeQueue();
    cout<<"  当前队列元素为：";
    cirqueue.PrintQueue();

    cout<<"队列是否为空：";
    if(cirqueue.Empty()) cout<<"是";
    else cout<<"否";
    }catch(const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

CirQueue.h

#ifndef CIRQUEUE_H_INCLUDED
#define CIRQUEUE_H_INCLUDED
using namespace std;
const int MaxSize=100;//长度

template <typename T>
struct CirQueue
{
    CirQueue();//构造函数
    void EnQueue(T x);//入队操作
    T DeQueue();//出队操作，将队头元素请出队列
    T GetHead();//取队头元素，不删除
    bool Empty();//判空
    void PrintQueue();//打印出来
private:
    T data[MaxSize];
    int front,rear;//队列中头和尾的下标
};

template <typename T>
CirQueue<T>::CirQueue()
{
    rear=front=MaxSize-1;//尾是真的尾（有元素），头是前一个，头指向这里是没有元素的
    //所以整个循环队列满的时候，还是留了一个位置，即头指向的位置
}

template <typename T>
void CirQueue<T>::EnQueue(T x)
{
    if((rear+1)%MaxSize==front) throw std::runtime_error("溢出");//当尾元素后一个是头元素时，说明队满了，插不进了
    rear=((rear+1)%MaxSize);
    data[rear]=x;
}

template <typename T>
T CirQueue<T>::DeQueue()
{
    if(rear==front) throw std::runtime_error("下溢");//当尾等于头时，说明说明全空了
    front =(front+1)%MaxSize;
    return data[front];
}

template <typename T>
T CirQueue<T>::GetHead()
{
    return data[(front+1)%MaxSize];
}

template <typename T>
bool CirQueue<T>::Empty()
{
    if(rear==front) return true;
    else return false;
}

template <typename T>
void CirQueue<T>::PrintQueue()
{
    int length =(rear+1)%MaxSize-(front+1)%MaxSize;
    int a=front;
    for(int i=0;i<length;i++)
    {
        cout<<data[(a+1)%MaxSize]<<" ";
        a=(a+1)%MaxSize;
    }
    cout<<endl;
}



#endif // CIRQUEUE_H_INCLUDED

Linkqueue.h

#ifndef LINKQUEUE_H_INCLUDED
#define LINKQUEUE_H_INCLUDED

using namespace std;
template <typename T>
struct Node //定义节点
{
    T data;//数据域
    Node<T> *t;//指针域
};

template <typename T>
struct Linkqueue
{
    Linkqueue();//构造函数
    void EnQueue(T x);//入队操作
    void Printqueue();//队列元素打印出来
    T Dequeue();//出队操作，请出队伍
    T GetHead();//取队头元素
    bool Empty();//判空
private:
    Node<T> *front;//队列的头结点,数据域无元素
    Node<T> *rear;//队列的最后一个结点
    int count;
};

template <typename T>
Linkqueue<T>::Linkqueue()
{
//    Node<T> *front=nullptr;
//    front->t=nullptr;
//    rear=front;
//    count=0;
      Node<T> *s=nullptr;
      s=new Node<T>;s->t=nullptr;
      front=rear=s;
}



template <typename T>
void Linkqueue<T>::EnQueue(T x)
{
    Node<T> *s=new Node<T>;
    s->data=x;s->t=nullptr;
    rear->t=s;
    rear=s;
}

template <typename T>
void Linkqueue<T>::Printqueue()
{
    Node<T> *p=front->t;
    while(p!=nullptr)
    {
        cout<<p->data<<" ";
        p=p->t;
    }
    cout<<endl;
}

template <typename T>
T Linkqueue<T>::Dequeue()
{
    if(rear==front) throw std::runtime_error("下溢");
    Node<T> *s=front->t;
    T x=s->data;
    front->t=s->t;
    if(s->t==nullptr)
    {
        rear=front;
    }
    delete s;
    return x;
}

template <typename T>
T Linkqueue<T>::GetHead()
{
    return front->t->data;
}

template <typename T>
bool Linkqueue<T>::Empty()
{
    if(front==rear) return true;
    else return false;
}



#endif // LINKQUEUE_H_INCLUDED