c++ 实现对象迭代器

#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