#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 建構函式

    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);
}