带迭代器的循环队列的实现

#include <iostream>
#include <iterator>
using namespace std;
/**
 * 无线循环队列,可扩容(内部自动扩容)
 * 实现迭代器访问循环队列
 * @tparam T 
 */
template<class T>
class queue{
public:
    explicit queue(int capacity);
    queue();
    virtual ~queue();
    void push(T val);
    T pop();
    T front() const;
    bool empty() const;
    bool full() const ;
    bool expand();
    // iterator
    class iterator{
    public:
        explicit iterator(T *t = 0):t(t){}
        T& operator*() const {
            return *t;
        }
        bool operator!=(const iterator right){
            return t != right.t;
        }
        iterator operator++(int){
            iterator old = *this;
            ++t;
            return old;
        }
    private:
        T *t;
    };
    iterator begin(){
        return iterator(data);
    }
    iterator end(){
        return iterator(data+capacity-1);
    }
private:
    T *data;
    int front_t,rear;
    int size;
    int capacity{};
};

template<class T>
queue<T>::queue(int capacity) {
    this->capacity = capacity+1;
    data = new T[this->capacity];
    front_t = 0;
    rear = 0;
    size = 0;
}

template<class T>
queue<T>::queue() {
    capacity = 100;
    data = new T[capacity];
    size = 0;
    rear = 0;front_t = 0;
}

template<class T>
queue<T>::~queue<T>() {
    delete data;
}

template<class T>
void queue<T>::push(T val) {
    expand();
    data[rear] = val;
    rear = (rear + 1) % capacity;
    size++;
}

template<class T>
T queue<T>::pop() {
    if (!empty()){
        int val = data[front_t];
        front_t = (front_t + 1) % capacity;
        size--;
        return val;
    }
}

template<class T>
T queue<T>::front() const {
    if (!empty())
        return data[front_t];
}

template<class T>
bool queue<T>::expand() {
    if(full()){
        int new_capacity = capacity * 1.5;
        T *temp = new T[new_capacity];
        copy(data,data+capacity,temp);
        data = temp;
        capacity = new_capacity;
        delete []temp;
        return true;
    }
    return false;
}

template<class T>
bool queue<T>::empty() const {
    return size == 0;
}

template<class T>
bool queue<T>::full() const {
    return size == capacity;
}

int main(int argv,char** argc) {
    queue<int> q(3);
    q.push(12);
    q.push(13);
    q.push(10);
    // 迭代器测试
    queue<int>::iterator it = q.begin();
    while (it != q.end()){
        cout<<*it++<<endl;
    }
    // front方法
    cout<<q.front()<<endl;
}