不带 () 的访问器或对成员变量的 const 引用

Question

我有兴趣创建一个可以使用的类，就像

class MyClass {
  vector<int> m_vec;
public:
  // Either this
  const& vector<int> vec;
  // Or some version of this. 
  const& vector<int> getVec() { return m_vec } ;

  MyClass() : vec(m_vec) {}
  void changeVec() { m_vec.push_back(5); }
}

现在如果我想使用 getVec() 一样，语法有点麻烦：

myClass.getVec()[5]

我更希望能够以某种方式使用

myClass.vec[5]

而不暴露修改向量的能力。 IE，我希望成员变量是私有的，但变量的 const 版本是公共的，而不会产生语法或性能开销。

如果我添加 const&向量引用，编译器（至少我的 GCC 版本）实际上使类占用更多内存。那么

1. 如何为成员变量创建别名而不使其使用更多内存，或者
2. 如何避免 myVec()[] 访问器中的括号？仅定义 myVec(int idx) 并不是一个令人满意的选择，因为我想对其调用多个方法。

需要明确的是，这是一个示例 - 在实际情况下，其用法比矢量情况下更引人注目。此外，内存使用情况很重要，因为存在大量此类对象并将被复制，因此这并不是过早的优化。此时，我正在使用 getVec()[0] 方法，但它的丑陋快要了我的命。

Answer 1

如果由于某种原因 MyClass::operator[] 不合适，只需为您的向量创建一个小包装类。

struct Wrapper {
  friend class MyClass;
  int operator[](size_t s) const { return vec[s]; }
private:
  vector<int> vec;
};

class MyClass {
public:
  Wrapper vec;
};

Answer 2

您确定您正在尝试解决正确的问题吗？类的一个重要目的是避免向用户公开底层实现，在本例中您正在做这样的说明。

您确实应该仔细查看您的类的用户 API。

真正需要对容器进行哪些操作？您应该以这样的方式设计 API，其中的方法描述类的高级流程，而不是“获取隐藏的实现细节”。

如果您只需要提供对各种容器元素的访问，您可以提供开始/结束迭代器并允许在范围内运行的算法。或者，您可以提供诸如 for_each_boys 和 for_each_girls 之类的函数，将操作数回调到相应的函数。

Answer 3

作为建议，您可以重载 MyClass 的 operator[]：

int operator[] (size_t which) const {
   return m_vec[which]; 
}

这大大简化了访问向量的语法：myClass[5]。但是，如果您 a) 想要在您的类中公开多个向量，或者 b) 打算使用其他 std::vector 成员而不仅仅是数组下标，即 size() ...在这种情况下，你无法真正避免 getter 和括号。

Answer 4

最简单的是：

struct MyClass
{
    vector<int> const vec;

    MyClass()
    {
        vector<int>& mvec = const_cast<vector<int>&>(vec);
        // modify mvec
    }
};

Answer 5

首先，我认为这样做没有任何意义。现在，如果您打算避免使用 ()[] 语法（我坚持：我不会），您只需提供对该类型的引用即可。

class test {
   std::vector<int> m_data;
public:
   std::vector<int> &data;
   test() : m_data(), data( m_data ) {}
};

与包装器相比，它的优点是编码更简单，而且不会出现太多问题。缺点是您会泄露实现的详细信息：外部代码将取决于您根据您提供的引用的 std::vector 实现的对象。请注意，在这方面与包装器没有太大区别，因为在这两种情况下，您都提供对详细信息的访问（我将为您提供对我的内部结构的索引访问），这可能会或不会是个好主意。

其他易于编码但不是很好的解决方案可能意味着使用继承，例如：

class test : private std::vector<int>
{
public:
   using std::vector<int>::operator[];
};

这里的一个重要细节是您不应该从 STL 容器公开继承（事实上，作为一个< code>class ，上面的 private 关键字是可选的，因为继承默认是私有的，但我添加它是为了强调），它们并不是为多态工作而设计的。通过使用私有继承，您可以限制用户错误的风险，因为向量是一个实现细节。

如果稍后您决定更改另一个容器的向量（允许索引访问 - 再次，您承诺在接口中进行索引访问！），您只需要提供您自己的operator[] 实现和用户代码将无需更改即可编译。

Answer 6

你可以这样做：（并不是说我认为这是一个特别好的主意......）

class MyClass;

class Proxy{
    public:
    Proxy(MyClass& c); // store reference to c
    int const& operator[](...) const; // access c.vec

    private:
    MyClass& c;
};

class MyClass{
    public:
    // public read-only proxy for this->m_vec
    const Proxy vec;

    MyClass()
        : vec(*this){
    }
    ...
    private:
    vector<int> m_vec;
};

未经测试，但我相信你明白这个想法。这种模式对于提供数组切片之类的东西很有用。