c++封装循环队列和vector

循环队列类：

#include <iostream>

using namespace std;

template <typename T>
class MyQueue{
private:
    int head;
    int end;
    T *p;
    int size;
public:
    MyQueue(){}
    MyQueue(int s):p(new T(s)), size(s){
        this->head = 0;
        this->end = 0;
    }
    void addQuere(T q){
        int n = (end+size-head)%size;

        if(n < size - 1){
            *(p+end) = q;
            end = (end+1)%size;
            return ;
        }
        cout << "队列已满" << endl;
    }
    void deleteQueue(){
        head += 1;
    }
    void display(){
        int first = head;
        while(first != end){
            cout << *(p+first) << " ";
            first = (first+1)%size;
        }
        cout << endl;
    }
};

int main()
{
    MyQueue<int> m1(5);
    m1.addQuere(5);
    m1.addQuere(6);
    m1.addQuere(4);
    m1.addQuere(2);
    m1.addQuere(1);
    m1.display();
    m1.deleteQueue();
    m1.display();
    return 0;
}

vector：

#include <iostream>

using namespace std;

template<typename T>
class Myvector{
private:
    T *first;
    T *last;
    T *end;
public:
    Myvector(){}
    Myvector(int s): first(new T(s)){
        last = first;
        end = first+s;
    }
    ~Myvector(){
        cout << "析构" << endl;
    }
    Myvector(const Myvector<T> &p){
        int len = p.last-p.first;
        int size = p.end-p.first;

        this->first = new T[size];

        memcpy(this->first, p.first, len*sizeof(T));

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

    }
    Myvector & operator=(const Myvector<T> & p){
        this->first = p.first;
        this->last = p.last;
        this->end = p.end;
    }

    T &at(int n){
        int size = last-first;
        if(n > size || n < 0){
            return NULL;
        }
        return first[n];
    }

    bool empty(){
        return this->first == this->last;
    }

    bool full(){
        return this->last == this->end;
    }

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

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

    int size(){
        return last-first;
    }

    void clear(){
        last = first;
    }

    void expand(){
        int size2 = this->end - this->first;

        T *temp = new T[2*size2];

        memcpy(temp, this->first, size2*sizeof(T));

        delete []first;

        first = temp;
        last = first+size2;
        end = first+2*size2;
    }

    void push_back(const T val){
        if(this->full()){
            this->expand();
        }
        *last = val;
        last ++;
    }

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

    void display(){
        T *mid = first;
        while(mid < last){
            cout << *mid << " ";
            mid++;
        }
        cout << endl;
    }

};

int main()
{
    Myvector<int> m1(5);
    m1.push_back(5);
    m1.push_back(10);
    m1.push_back(12);
    m1.display();
    m1.pop_back();
    m1.display();
    return 0;
}