Question

我有两个非常不同的读写行为。在读取的情况下，我想复制一个相当难以提取数据结构的缓冲区。在写入时，我将只写无缓冲结构。

到目前为止，我一直在使用operator []进行访问，所以为了多态，我想继续这样做。

所以我的问题是：当访问时，调用哪个版本？我的想法是const被称为读取，而非const被称为写入。在这种情况下，这是一个简单的实现。否则，它可能会更棘手。

Answer 1

要完成您想要的操作，您通常需要operator[]返回代理，并重载operator=和operator T（其中T是原始类型）代理类型。然后，您可以使用operator T来处理读取，并使用operator =来处理写入。

编辑：代理的基本思想非常简单：返回一个代替原始对象的对象实例。目前，这将具有真正的平凡的语义（只需在向量中的指定索引处读取和写入char）;在你的情况下，operator=和（特别是）operator T内部的逻辑显然会更复杂，但这对基本结构几乎没有影响。

#include <vector>

class X {
    std::vector<char> raw_data;

    class proxy { 
        X &parent;
        int index;   
    public:
        proxy(X &x, int i) : parent(x), index(i) {}

        operator char() const { return parent.raw_data[index]; }

        proxy &operator=(char d) { 
            parent.raw_data[index] = d; 
            return *this;
        }
    };
public:
    X() : raw_data(10) {}
    proxy operator[](int i) { return proxy(*this, i); }
};

#ifdef TEST

#include <iostream>

int main() {
    X x;
    for (int i=0; i<10; i++)
        x[i] = 'A' + i;

    for (int i=0; i<10; i++)
        std::cout << x[i] << "\n";
    return 0;
}
#endif

Answer 2

重载决策基于this参数，即 - 关于对象的常量或缺少常量，可以调用operator[]。

Answer 3

由于读取和写入之间的行为是如此不同，您可能希望至少考虑不重载operator[]，而是制作单独的read和write方法。

要回答您的问题，它基于您正在操作的对象的常量。它不知道你将如何处理运算符的结果，因此它只有一个可以处理的对象，即调用运算符的对象。如果对象是非const的，它将始终调用运算符的非const（写）版本。你可以通过const_cast const来解决这个问题，但是单独的方法似乎是一种更好的方法。

Answer 4

这取决于你“分配”的内容：

const type& x=X[i]

将调用函数的const版本

type& x=X[i]

或

X[i]=x

将调用非const版本。最后，一个简单的任务

type x=X[i]

没有真正的方式可以说一个是“读”而另一个是“写”。基本上，const版本将返回一个数据视图，其中不反映更新。非consts版本将返回一个数据视图，其中可以反映更新，但在写入后没有语义提供刷新。

何时调用const运算符[]，何时调用非const运算符[]？

4 个答案: