Итератор

#include <iostream>  
using namespace std;
 
template<class T>
class list
{
    public:
    list();
    list(list&other);
    size_t size(void) const;
    bool empty(void) const;
    void push_back(int data);
    void push_front(int data);
    void clear(void);
    Iterator* begin(void);
    Iterator* end(void);
    virtual ~list();
    private:
    class Iterator
   {
     public:
     node operator*();
     Iterator(node*value);  
     private:
     node* value;  
     };
    class node
    {
        public:
        int data;
        node*next;
        node*prev;
        node(int data=0,node*next=nullptr,node*prev=nullptr);
        
    };
    node*head;
    node*tail;
    size_t _size;
} ;
template<class T>
node list<T>::Iterator::operator*() {return *this->value; }
list<T>::Iterator::Iterator(node*value): value(value){}
 
template<class T>
list<T>::node::node(int data,node*next,node*prev)
                   : data(data),next(next),prev(prev) {}
template<class T>
list<T>::list():head(nullptr),tail(nullptr),_size(0) {}
 
template<class T>
size_t list<T>::size() const {return this->_size;} 
 
template<class T>
bool list<T>::empty() const {return new this->_size == 0 ? true : false;}
 
template<class T>
void list<T>::push_back(int data)
{
    node*tmp = new node(data);
    if(this->head!=nullptr)
    {
        tmp->prev=this->tail;
        this->tail->next=tmp;
        this->tail=tmp;
    }
    else
    {
        this->head=this->tail=tmp;
        this->head->next=this->tail;
        this->head->prev=nullptr;
        this->tail->next=nullptr;
    }
    ++this->_size;
}
 
template<class T>
void list<T>::push_front(int data)
{
    node*tmp = new node(data);
    if(this->head!=nullptr)
    {
        tmp->next=this->head;
        this->head->prev=tmp;
        this->head=tmp;
    }
    else
    {
        this->head=this->tail=tmp;
        this->head->next=this->tail;
        this->head->prev=nullptr;
        this->tail->next=nullptr;
    }
    ++this->_size;
}
 
template<class T>
Iterator<T>* list<T>::begin(){return new Iterator(this->head);}
 
template<class T>
Iterator<T>* list<T>::end(){return new Iterator(this->tail);}
 
 
 
template<class T>
void list<T>::clear()
{
    while(this->head!=nullptr)
    {
        node*tmp=this->head->next;
        delete this->head;
        this->head=tmp;
        --this->_size;
    }
}
 
template<class T>
list<T>::~list()
{
    while(this->head!=nullptr)
    {
        node*tmp=this->head->next;
        delete this->head;
        this->head=tmp;
    }
}
 
 
int main(void)
{
    list<int> a;
    a.push_back(999);
    a.push_front(69);
    a.push_front(69);
    /*a.print();*/
    cout<<boolalpha<<a.empty()<<endl;
    //cout<<*(a.begin())<<endl;
    a.begin();
 
 
 return EXIT_SUCCESS; 
}