作业8.30 C++封装栈与队列容器适配器

栈

实现代码

#include <iostream>

using namespace std;

template <typename T>
class MyStack
{
private:
    T *bottom;
    T *top;
    T *end;
public:
    //构造函数
    MyStack(int size=1)
    {
        bottom=new T[size];
        top=bottom;
        end=bottom+size;
    }
    //析构函数
    ~MyStack()
    {
        delete []bottom;
        end=bottom=top=nullptr;
    }
    //拷贝构造
    MyStack (const MyStack &other)
    {
        //先计算出原空间的尺寸
        int len = other.top-other.bottom;
        int size=other.end-other.bottom;
        this->bottom=new T[size];
        mencpy(this->bottom,other.bottom,len*sizeof(T));

        //将对象的另外两个指针指向对应位置
        this->top = this->bottom+len;
        this->end = this->bottom+size;
    }

    //拷贝赋值
    MyStack& operator=(const MyStack &other)
    {
        //先计算出原空间的尺寸
        int len = other.last-other.first;
        int size=other.end-other.first;
        this->first=new T[size];
        mencpy(this->first,other.first,len*sizeof(T));

        //将对象的另外两个指针指向对应位置
        this->last = this->first+len;
        this->end = this->first+size;
        return *this;
    }

    //判空
    bool empty()
    {
        return this->bottom == this->top;
    }

    //判满
    bool full()
    {
        return this->top == this->end;
    }

    //扩容原则：2倍扩容
    void expend()
    {
        //获取当前容器总量
        int size=this->end-this->bottom;

        //在堆区重新申请一个2倍的空间
        T* temp = new T[2*size];

        //将原空间数据放到新申请的空间中
        memcpy(temp,this->bottom,size*sizeof(T));

        //释放原来空间
        delete []bottom;

        //更新指针指向
        bottom =temp;

        //更新其他指针
        top=bottom+size;
        end=bottom+2*size;
    }
    //入栈
    void push(const T value)
    {
        if(this->full())
        {
            this->expend();
        }
        *top=value;
        top++;
    }

    //出栈
    T& pop()
    {
        if(this->empty())
        {
            throw -1;
        }

        //尾指针前移
        top--;
        return *top;
    }

    //获取栈顶元素
    T& getTop() const
    {
        return  *(top-1);
    }

    int size()
    {
        return end-bottom;
    }

    int len()
    {
        return top-bottom;
    }

    void show()
    {
        for(int i=0;i<len();i++)
        {
            cout<<bottom[i]<<" ";
        }
        cout<<endl;
    }

};
int main()
{
    MyStack<int> s;
    for(int i=1;i<=10;i++)
    {
        s.push(i);
        cout<<"栈容量："<<s.size()<<endl;
    }
    cout<<"栈元素：";
    s.show();
    try {
        cout<<"出栈："<<s.pop()<<endl;
        cout<<"出栈："<<s.pop()<<endl;
        cout<<"出栈："<<s.pop()<<endl;
    } catch (int e) {
        if(e==-1)
        {
            cout<<"栈空，出栈失败"<<endl;
        }
    }
    cout<<"栈元素：";
    s.show();
    return 0;
}

运行结果

队列

实现代码

#include <iostream>

using namespace std;

template <typename T>
class MyQueue
{
private:
    int front;
    int rear;
    T *first;
    int size;
public:
    //构造函数
    MyQueue(int size=1)
    {
        first=new T[size];
        rear=front=0;
        this->size=size;
    }
    //析构函数
    ~MyQueue()
    {
        delete []first;
        size=front=rear=0;
    }
    //拷贝构造
    MyQueue (const MyQueue &other)
    {
        this->first=new T[other.size];
        this->size=other.size;
        mencpy(this->first,other.first,size*sizeof(T));

        //将对象的另外两个指针指向对应位置
        this->rear = other.rear;
        this->front = other.front;
    }

    //拷贝赋值
    MyQueue& operator=(const MyQueue &other)
    {
        this->first=new T[other.size];
        this->size=other.size;
        mencpy(this->first,other.first,size*sizeof(T));

        //将对象的另外两个指针指向对应位置
        this->rear = other.rear;
        this->front = other.front;
        return *this;
    }

    //判空
    bool empty()
    {
        return this->front == this->rear;
    }

    //判满
    bool full()
    {
        return this->front == (this->rear+1)%size;
    }

    //扩容原则：2倍扩容
    void expend()
    {
        //在堆区重新申请一个2倍的空间
        T* temp = new T[2*size];

        //将原空间数据放到新申请的空间中
        memcpy(temp,this->first,size*sizeof(T));

        //释放原来空间
        delete []first;

        //更新指针指向
        first =temp;

        size=2*size;
    }

    //入队
    void push(const T value)
    {
        if(this->full())
        {
            this->expend();
        }
        first[rear]=value;
        rear=(rear+1)%size;
    }

    //出队
    T& pop()
    {
        if(this->empty())
        {
            throw -1;
        }

        //尾指针前移
        int temp=front;
        front=(front+1)%size;
        return first[temp];
    }

    //获取队首元素
    T& getfront() const
    {
        return  first[front];
    }

    //获取队尾元素
    T& getrear() const
    {
        return  first[rear];
    }

    int getSize()
    {
        return this->size;
    }

    int len()
    {
        return (rear-front+size)%size;
    }

    void show()
    {
        for(int i=front;i<front+len();i++)
        {
            cout<<first[i]<<" ";
        }
        cout<<endl;
    }

};
int main()
{
    MyQueue<int> q;
    for(int i=1;i<=10;i++)
    {
        q.push(i);
        cout<<"队列容量："<<q.getSize()<<endl;
    }
    cout<<"队列元素：";
    q.show();
    try {
        cout<<"出队："<<q.pop()<<endl;
        cout<<"出队："<<q.pop()<<endl;
        cout<<"出队："<<q.pop()<<endl;
    } catch (int e) {
        if(e==-1)
        {
            cout<<"队列为空，出队失败"<<endl;
        }
    }
    cout<<"队列元素：";
    q.show();
    return 0;
}

运行结果