c++双向链表实现

//
// Created by admin on 2021/10/21.
// List 双向链表实现
//

#ifndef HELLOWORLD_LIST_H
#define HELLOWORLD_LIST_H

// List类
template<typename Object>
class List {
    // 节点类
    struct Node {
        Object mData;
        Node *prev;
        Node *next;

        explicit Node(const Object &d = Object{}, Node *p = nullptr, Node *n = nullptr);  // 构造函数
    };

public:
    // 迭代器声明
    class Iter {
        friend class List;

        Node *currNode;  // 当前节点
    public:
        explicit Iter(Node *node);  // 构造函数
        Iter operator++();  // 重载前置++运算符
        Iter operator++(int);  // 后置++运算符重载
        Object &operator*();  // 重载*运算符
        bool operator!=(const Iter &iter) const;
        Iter operator--();
    };

    List(); // List 构造函数
    ~List(); // 析构函数

    Iter insert(Iter iter, const Object &object); // 插入函数
    Iter pushBack(const Object &object) { return Iter{insert(end(), object)}; }

    void pushFront(const Object &object);  //头部插入
    void popFront() { erase(begin()); }  // 删除头部元素
    void popBack() { erase(--end()); }    // 删除尾部元素

    Iter erase(Iter iter); // 删除元素
    void clear();  // 清除所有元素
    bool empty() { return mSize == 0; }  // 是否为空
    Object &front() { return *begin(); }  // 获取首元素
    Object &back() { return *--end(); }  // 获取尾元素


    Iter begin() { return Iter{head->next}; }  // 头节点
    Iter end() { return Iter{tail}; }   // 尾节点
    unsigned size() { return mSize; }  // 获取尺寸

private:
    Node *head;     // 头节点
    Node *tail;     // 尾节点
    unsigned mSize; // 链表元素个数
};


// 节点类
template<typename Object>
List<Object>::Node::Node(const Object &d, Node *p, Node *n): mData(d), prev(p), next(n) {}

template<typename Object>
List<Object>::Iter::Iter(List::Node *node): currNode(node) {}  // Iter构造函数实现

template<typename Object>
typename List<Object>::Iter List<Object>::Iter::operator++() {
    currNode = currNode->next;
    return *this;
}

template<typename Object>
Object &List<Object>::Iter::operator*() {
    return currNode->mData;
}

template<typename Object>
bool List<Object>::Iter::operator!=(const List::Iter &iter) const {
    return this->currNode != iter.currNode;
}

template<typename Object>
typename List<Object>::Iter List<Object>::Iter::operator--() {
    currNode = currNode->prev;
    return *this;
}

template<typename Object>
typename List<Object>::Iter List<Object>::Iter::operator++(int) {
    auto preNode = *this;
    currNode = currNode->next;
    return preNode;
}

template<typename Object>
List<Object>::List() {
    mSize = 0;
    head = new Node;  // 创建首节点
    tail = new Node;  // 创建尾节点
    head->next = tail;
    tail->prev = head;
}

template<typename Object>
typename List<Object>::Iter List<Object>::insert(List<Object>::Iter iter, const Object &object) {
    Node *node = iter.currNode;
    ++mSize;
    return Iter{node->prev = node->prev->next = new Node{object, node->prev, node}};
}

template<typename Object>
typename List<Object>::Iter List<Object>::erase(List<Object>::Iter iter) {
    Node *node = iter.currNode;
    Iter ret{node->next};
    node->prev->next = node->next;
    node->next->prev = node->prev;
    --mSize;
    delete node;
    return ret;
}

template<typename Object>
void List<Object>::clear() {
    while (!empty()) erase();
}

template<typename Object>
void List<Object>::pushFront(const Object &object) {
    insert(begin(), object);
}

template<typename Object>
List<Object>::~List() {
    clear();
    delete tail;
    delete head;
}

#endif //HELLOWORLD_LIST_H