c++模版编程实践-CRTP实现List的迭代器loop based for

c++ 迭代器和java的迭代器实现方式差别极大

下面展示stl list 迭代器的实现方式，
使用的是模版技巧CRTP
CRTP前置示例

好处是只需要实现几个简单接口，便能借用这几个接口实现一整套接口，非常方便， CRTP详细好处百度一下。

#include <iostream>
#include <utility>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>

#include <fstream>
#include <array>

using namespace std;

/* 1. + increment();
 * 2. - decrement();
 * 3. = equals();
 * 4. 【】 at();
 * 5.  less();
 * */

// 外观
template<
        typename Derived,
        typename Value,
        typename Category,
        typename Reference = Value &,
        typename Distance = std::ptrdiff_t
>
class IteratorFacade {
public:
    using value_type = typename std::remove_const<Value>::type; using reference = Reference;
    using pointer = Value *;
    using difference_type = Distance;
    using iterator_category = Category;

    Derived &asDerived() {
        return *static_cast<Derived *>(this);
    }

    Derived const &asDerived() const {
        return *static_cast<Derived const *>(this);
    }

    // input iterator interface:
    reference operator*() const {
        return asDerived().dereference();
    }

    pointer operator->() const {
        return &(asDerived().dereference());
    }

    Derived &operator++() {
        asDerived().increment();
        return asDerived();
    }

    Derived operator++(int) {
        Derived temp(asDerived());
        temp.increment();
        return temp;
    }

    friend bool operator==(IteratorFacade const &lhs, IteratorFacade const &rhs) {
        return lhs.asDerived().equals(rhs.asDerived());
    }

    friend bool operator!=(IteratorFacade const &lhs, IteratorFacade const &rhs) {
        return !(lhs == rhs);
    }

    Derived &operator--() {
        asDerived().decrement();
        return asDerived();
    }

    Derived operator--(int) {
        Derived temp(asDerived());
        temp.decrement();
        return temp;
    }

    reference operator[](difference_type n) const {
        return asDerived().at(n);
    }

    Derived &operator+=(difference_type n) {

    }

    friend difference_type operator-(IteratorFacade const &lhs, IteratorFacade const &rhs) {
        difference_type res{};
        if constexpr (is_same_v<std::forward_iterator_tag, Category>) {

        }
    }

    friend bool operator<(IteratorFacade const &lhs, IteratorFacade const &rhs) {
        return lhs.asDerived().less(rhs.asDerived());
    }
};

// list节点
template<typename T>
class ListNode;

// list迭代器
template<typename T>
class ListNodeIterator : public IteratorFacade<ListNodeIterator<T>, T, std::forward_iterator_tag> {
private:
    ListNode<T> *current = nullptr;
public:
    ListNodeIterator(ListNode<T> *node) : current(node) {}

    T &dereference() const {
        return current->value;
    }

    void increment() {
        current = current->next;
    }

    bool equals(ListNodeIterator const &other) const {
        return current == other.current;
    }
};

template<typename T>
class ListNode {
public:
    T value;
    ListNode<T> *next;

    ListNode(const T &t) {
        value = t;
        next = nullptr;
    }

    ListNode() : value(0), next(nullptr) {}

    ~ListNode() { delete next; }
};

// list简单实现
template<typename T>
class List {
private:
    ListNode<T> head;
    ListNode<T> *tail;

public:
    List() : tail(nullptr) {
        tail = &head;
    }

    void insertFront(const T &t) {
        ListNode<T> *node = new ListNode(t);
        node->next = head.next;
        head.next = node;
        if (tail == &head) {
            tail = node;
        }
    }

    void insertBack(const T &t) {
        ListNode<T> *node = new ListNode(t);
        tail->next = node;
        tail = node;
    }

    ListNodeIterator<T> begin() {
        return ListNodeIterator(head.next);
    }

    ListNodeIterator<T> end() {
        return ListNodeIterator(static_cast<ListNode<T> *>(nullptr));
    }
};


int main() {
    List<int> list;
    list.insertFront(1);
    list.insertBack(2);
    list.insertBack(3);
    list.insertBack(4);
    list.insertFront(5);
    for (auto it : list) {
        cout << it << endl;
    }
}