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

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

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

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

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 

using namespace std;



// 外观
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::type; using reference = Reference;
    using pointer = Value *;
    using difference_type = Distance;
    using iterator_category = Category;

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

    Derived const &asDerived() const {
        return *static_cast(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) {

        }
    }

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

// list节点
template
class ListNode;

// list迭代器
template
class ListNodeIterator : public IteratorFacade, T, std::forward_iterator_tag> {
private:
    ListNode *current = nullptr;
public:
    ListNodeIterator(ListNode *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
class ListNode {
public:
    T value;
    ListNode *next;

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

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

    ~ListNode() { delete next; }
};

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

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

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

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

    ListNodeIterator begin() {
        return ListNodeIterator(head.next);
    }

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


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

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

C/C++/C#相关栏目本月热门文章