c++ 实现对象迭代器

叁歲伎倆 2023-02-11 11:28 18阅读 0赞

#include <iostream>
    #include <list>
    #include <vector>
    using std::list;
    
    
    template <typename T, typename To>
    struct Caster { 
        list<To> *ptr;
        Caster(list<To>* ptr) : ptr(ptr) { };
        struct Iter { 
            typename list<To>::iterator iter, next;
            Iter(typename list<To>::iterator iter)
                    : iter(iter), next(std::next(iter)) { }
            T operator*() {  return iter->operator T(); }
            Iter& operator++() {  iter = next++; return *this; }
            Iter operator++(int) {  auto tmp = *this; ++(*this); return tmp; }
            bool operator!=(const Iter& other) {  return iter != other.iter; }
            // bool operator!=(Iter& a, Iter& other) { return a != other.iter; }
        };
        Iter begin() const {  return Iter(ptr->begin()); }
        Iter end() const {  return Iter(ptr->end()); }
        size_t size() {  return ptr->size(); }
        T front() {  return ptr->front().operator T(); }
        T back() {  return ptr->back().operator T(); }
    };
    
    struct  Var;
    
    struct Node { 
        struct input_t;
        int id;
        list<input_t> _inputs;
        struct input_t { 
            Node* node;
            input_t(Node* n) : node(n) { 
            }
            operator Node*() { 
                return node;
            }
            operator Var*() { 
                return (Var*)(node);
            }
        };
        void add_inputs(const std::vector<Node*>& nodes) { 
            for (auto& p : nodes) { 
                _inputs.push_back(input_t(p));
            }
        }
        inline Caster<Node*, Node::input_t> inputs() { return &_inputs; }
    };
    
    struct Var : Node { 
    
    };
    
    int main() { 
        Node* node = new Node();
        Node* node2 = new Node();
        node->add_inputs(std::vector<Node*>{ node2});
        node->add_inputs(std::vector<Node*>{ node2});
        Caster<Node*, Node::input_t> out =  node->inputs();
        for(const auto& data : out) { 
            std::cout << data->id << std::endl;
        }
        Caster<Node*, Node::input_t>::Iter it = out.begin();
        auto end = out.end();
        while (it != end) { 
            // std::cout << it.operator*()->id << std::endl;
             std::cout << (*it)->id << std::endl;
             it++;
        }
    }

输出：

0
    0
    0
    0