数据结构与算法分析：实现list【理解 iter++ 和 ++iter 】

来自《数据结构与算法分析》第三章，实现类的时候设计底层的接口越少越好，如只在 erase 中执行 delete，其他删除操作只调用 erase，而不是直接用 delete

#include <iostream>
using namespace std;

template<typename T>
class List{
    //双向链表实现,包含了头尾哨兵节点可以把头尾节点视为普通节点处理简化程序
private:

    struct Node{ //struct是默认成员公有的class,这里其本身是private的,不会有什么问题;
        T data;
        Node* pre;
        Node* next;
        Node(const T& d=T(),Node* p=nullptr,Node* n=nullptr):data(d),pre(p),next(n){};
    };
    int size;
    Node* head;
    Node* tail;
    void init(){
        size=0;
        head=new Node;
        tail=new Node;
        head->next=tail;
        tail->pre=head;
    }

public:

    class const_iterator{
    protected:  //protected使此类的子类能访问成员,但其他类不可以
        Node* cur;
        T& retrieve() const {return cur->data;}
        const_iterator(Node* p):cur(p){}; //构造函数
        friend class List<T>; //使List能访问成员
    public:
        const_iterator():cur(nullptr){}; //重载构造函数,默认存储空指针
        const T& operator*() const {return retrieve();}
        const_iterator& operator++(){  //++iter时调用,对比下面的iter++重载,可以知道一般++iter快于iter++
            cur=cur->next;
            return *this;
        }
        const_iterator& operator++(int){ //重载后缀++,int的意义仅仅是为了重载的语法需要提供不同的函数标识,iter++时调用
            const_iterator old=*this;
            ++(*this); //实际调用了上面实现的operator++()
            return old;
        }
        bool operator== (const const_iterator& rhs) const{return cur==rhs.cur;}
        bool operator!= (const const_iterator& rhs) const{return !(*this==rhs);} //这行实际调用了上面重载的==


    };
    class iterator:public const_iterator{   //iterator公有派生自const_iterator,能用父类的地方都能用子类,子类比父类功能更多
    protected:
        iterator(Node* p):const_iterator(p){}; //调用父类构造函数
        friend class List<T>;
    public:
        iterator(){};
        T& operator*(){return this->retrieve();}        //不用this调用的话有时会编译出错
        const T& operator*() const{return const_iterator::operator*();}
        iterator& operator++(){  //++iter时调用,对比下面的iter++重载,可以知道一般++iter快于iter++
            //cout << "调用++iter" << endl;
            this->cur=this->cur->next;
            return *this;
        }
        iterator& operator--(){  //++iter时调用,对比下面的iter++重载,可以知道一般++iter快于iter++
            this->cur=this->cur->pre;
            return *this;
        }
        iterator& operator++(int){ //重载后缀++,int的意义仅仅是为了重载的语法需要提供不同的函数标识,iter++时调用
            iterator old=*this;
            ++(*this);
            return old;
        }
    };
    List(){
        init();
    };
    List(const List& rhs){
        init();
        *this=rhs;
    }
    ~List(){
        clear();
        delete head;
        delete tail;
    }
    const List& operator=(const List& rhs){
        if (this==&rhs) return *this;
        clear();
        for (const_iterator itr=rhs.begin();itr!=rhs.end();++itr) push_back(*itr);
        return *this;

    }
    iterator begin(){return iterator(head->next);}  //begin返回的是真正的头节点,不是哨兵节点
    const_iterator begin() const {return const_iterator(head->next);} //函数后面的const表示不会修改成员变量,是const_iterator的关键
    iterator end(){return iterator(tail);}          //end返回的是哨兵节点,不是真正的尾结点
    const_iterator end() const{return const_iterator(tail);}
    int Size() const {return size;}
    bool empty() const {return size==0;}
    void clear(){while (!empty()) pop_front();}
    T& front(){return *begin();}
    const T& front() const {return *begin();}

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

    void push_front(const T& x){insert(begin(),x);}
    void push_back(const T& x){insert(end(),x);}

    void pop_front(){erase(begin());}
    void pop_back(){erase(--end());}

    iterator insert(iterator itr,const T& x){
        Node* p=itr.cur;
        size++;
        return iterator(p->pre=p->pre->next=new Node(x,p->pre,p)); //插入的节点之前的节点是p->pre,之后的节点是p
    }
    iterator erase(iterator itr){
        Node* p=itr.cur;
        iterator retVal(p->next);   //erase删除节点后返回后一个节点
        size--;
        p->pre->next=p->next;  //修改删除节点的前一个节点next
        p->next->pre=p->pre;    //修改删除节点的后一个节点pre
        delete p;
        return retVal;
    }
    iterator erase(iterator start,iterator end){
        for (iterator itr=start;itr!=end;) itr=erase(itr);
        return end;
    }
};



int main(){
    List<int> l;
    for (int i=1;i<10;i++) l.push_back(i);
    l.pop_back();
    l.insert(l.end(),37);
    //cout << *(--l.end());
    for (List<int>::iterator itr=l.begin();itr!=l.end();++itr) cout << *itr << ' ';

    l.erase(l.begin(),++l.begin());
    cout << endl;
    for (auto itr=l.begin();itr!=l.end();itr++) cout << *itr << ' ';

    return 0;
}