# 2023/4/3 vector和循环队列

2023/4/3 vector和循环队列

#include <iostream>

using namespace std;

template <typename T>
class Myvector
{
private:
    T * first;
    T * last;
    T * end;

public:
    //构造
    Myvector(int size = 2)
    {
        first = new T[size];
        first = last;
        end = first + last;
    }
    //析构函数
    ~Myvector()
    {
        delete [] first;
        first = last = end = nullptr;
    }
    //拷贝构造
    Myvector(const Myvector<T> & other)
    {
        int len = other.last - other.first;
        int size = other.end - other.first;

        this->first = new T[size];
        memcpy(this->first,other.first,len*sizeof(T));

        this->last = this->first + len;
        this->end = this->first + size;

    }
    //拷贝赋值
    Myvector<T> &operator=(const Myvector<T>&other)
    {
        int len = other.last - other.first;
        int size = other.end - other.first;

        this->first = new T[size];
        memcpy(this->first,other.first,len*sizeof(T));

        this->last = this->first + len;
        this->end = this->first + size;

        return *this;
    }


    //at()
    T &at(int pos)
    {
        if(pos < 0 || pos > this->len())
        {
            cout << "越界" << endl;
        }
        return *(first+pos);
    }
    //empty()
    bool empty()
    {
        return last == first ? true:false;
    }

    //full()
    bool full()
    {
        return end == last ? true:false;
    }

    //front()
   const T& front()const
    {
        return *first;
    }

    //back()
    const T& back()const
    {
        return *(last-1);
    }

    //size()
    int size()const
    {
        return end - first;
    }

    int len()const
    {
        return last - first;
    }

    //clear()
    void clear()
    {
        last = first;
    }

    //expand()  二倍扩容函数
    void expand()
    {
        int size = this->end - this->first;

        T *temp = new T[2*size];
        memcpy(temp->first,first,size*sizeof(T));
        delete []this;
        first = temp;
        last = first + size;
        end = first + 2*size;

    }

    //push_back()
    void push_back(const T&other)
    {
        if(this->full())
        {
            this->expand();
        }

        *last = other;
        last ++;

    }

    //pop_back()
    void pop_back()
    {
        if(this->empty())
        {
            return;
        }
        --last;
    }

};


template<typename T>
class MyQueue
{
private:
    T* queue;
    size_t maxSize;
    size_t front;
    size_t rear;
public:
    MyQueue(size_t s):queue(new T[s]),maxSize(s),front(0),rear(0){}
    ~MyQueue()
    {
        delete [] queue;
    }
    bool empty()const
    {
        return front==rear;
    }
    bool full()const
    {
        return (rear+1)%maxSize==front;
    }
    void dequeue()
    {
        if(empty())
        {
            throw ;
        }
        front=(front+1)%maxSize;
    }
    void enqueue(const T& val)
    {
        if(full())
        {
            throw ;
        }
        queue[rear]=val;
        rear=(rear+1)%maxSize;
    }
    int size() const
    {
        return (rear+maxSize-front)%maxSize;
    }
    void show()const
    {
        for(int i=0;i<size();i++)
        {
            cout<<queue[i]<<" ";
        }
        cout<<endl;
    }
};