遵循整数索引列表的自定义类迭代器？

Question

我有一个模板类 myClass，它拥有一个 std::vector 的实例，并且我重载了 [] 运算符以将成员向量上的索引 std::vector<int> 作为参数并返回一个辅助班级mySubset

template <typename _type> 
class myClass {
    // ...
    std::vector<_type> data;
    // ...
    class mySubset {
        myClass<_type>* mc; 
        const std::vector<int>::iterator &idx; 
    public:
        //constructor
        mySubset(myClass<_type> * _m, const std::vector<int>& _idx);
        // input operator overloads (for data and range input)
        template <typename _input_type> mySubset& operator=(const std::vector<_input_type>& _vals);
        mySubset& operator=(const mySubset& _sbst);
    };

public:

    myClass();
    ~myClass(); 
    // ...
    //acess operator
    mySubset operator[](const std::vector<int>& _idx) { return mySubset(_idx); };
    // ...
    //iterator
    typename std::vector<_type>::iterator begin() {return data.begin();};
    typename std::vector<_type>::iterator end();  {return data.end();  };
    // ...
}

我可以使用[] 运算符直接获取和设置值，但我希望能够使用基于范围的循环，例如

// ...
myClass<float> foo;
// ...
std::vector<int> indices (3);
indices[0] = 3;
indices[1] = 6;
indices[2] = 10;
// ...
foo[indices] = std::vector<float> (3, 0.47);

for (auto& fval : foo[indices]) { /* do stuff*/}

根据我收集到的信息，我需要advance( InputIt& it, Distance n ); 来实现我想要的，并将begin() 和end() 成员添加到mySubset，这将返回一个带有@987654333 的类似迭代器的类型对象@ 运算符通过查看索引向量来递增迭代器：

class myIterator {
    mySubset * sb;
    std::vector<_type> it; // myClass::data iterator
public:
    myIterator(mySubset * _sb, int pos): sb(_sb) { it = sb->mc->data.begin() + sb->idx[0]; }   ;
    myIterator& operator++() { };
    myIterator& operator!=(myIterator& _other) { };
};

//.. mySubset
myIterator begin();
myIterator end();

但目前我无法理解实现这一目标所需的实际语法是什么？

Answer 1

我会偷懒的。

在mySubset 上实施_type& operator[](size_t) 和.size()。

template<class C>
struct range_for_helper{
  using self=range_for_helper;
  C* c=0;
  std::size_t i = 0;
  self(C* cin, std::size_t idx):c(cin),i(idx){}
  friend bool operator==(self lhs, self rhs){return lhs.i==rhs.i;}
  friend bool operator!=(self lhs, self rhs){return lhs.i!=rhs.i;}
  void operator++(){++i;}
  decltype(auto) operator*(){ return (*c)[i]; }
};

然后添加

到mySubset 并完成。

它不是真正的迭代器，但对于for(:) 循环来说已经足够了。它可以扩展到一个真正的迭代器，就像我说的，懒惰的。

还有：

range_for_helper<mySubset> begin() const { return {this,0}; }
range_for_helper<mySubset> end() const { return {this,size()}; }

如果您的[] 对const 重载，则可以正常工作，这很好。