如何为一个类提供多个开始/结束代理

Question

给定类

struct Data
{
  void bar() const;
  void baz();
}

class Foo
{
  std::vector<Data> data;
  std::map<size_t, Data> indexed_data;
}

我想在 Foo 类中实现一些东西，以便我可以执行以下操作：

int main()
{
  Foo foo;

  for(const auto& data : foo.data())
    data.bar();

  for(auto& data : foo.indexed_data())
    data.baz();

  const auto& foo_ref = foo;
  for(auto& data : foo_ref.data())
    data.baz();  // constness violated, shouldn't compile
}

但是，我不想仅仅通过返回对容器的引用来公开类内部。我也可以使用我想要迭代的范围没有作为容器实现的类。所以我基本上想创建某种代理对象，它比开始/结束对的包装器多一点，这样我就可以在我的类中迭代多个东西。 此外，我希望它是正确的，如上所示。是否有任何众所周知的模式来实现这一点？

Answer 1

考虑三种情况。

---

如果您想完全访问您的内部数据，只需创建一个函数来返回它：（只需将成员设为公开也是一种选择）

class C {
public:
          Type& data()       { return data_; }
    const Type& data() const { return data_; }
private:
    Type data_;
};

---

如果您想授予对内部数据的只读访问权限，只需删除非常量重载：

class C {
public:
    const Type& data() const { return data_; }
private:
    Type data_;
};

---

如果您想授予对内部数据的仅元素访问权限，即，您可以对每个单独的元素进行可变访问（当C 本身是非常量时），但您不能更改容器本身（例如，插入一个新元素），您需要返回一个代理。从 C++20 开始，我们可以返回一个std::ranges::ref_view：

class C {
public:
    auto data()       { return std::ranges::ref_view(data_); }
    auto data() const { return std::ranges::ref_view(data_); }
private:
    Type data_;
};

如果 C++20 不可用，您可以使用 Ranges library。这样，用户可以访问各个元素，但不能更改容器本身。

或者，您可以编写自己的（极简）代理：

template <typename R>
class Proxy {
public:
    explicit Proxy(R& r) :range{r} {}
    auto begin() const { return range.begin(); }
    auto   end() const { return range.end(); }
private:
    R& range;
};

那你可以回Proxy{data_}:

class C {
public:
    auto data()       { return Proxy{data_}; }
    auto data() const { return Proxy{data_}; }
private:
    Type data_;
};

在C++17之前，不用类模板参数推导可以这样写：

class C {
public:
    auto data()       { return Proxy<      Type>{data_}; }
    auto data() const { return Proxy<const Type>{data_}; }
private:
    Type data_;
};