仅为特定类的成员重载 operator[]

Question

编辑：MyClass 已重命名为 ReverseStringAccess 以消除歧义。

我有一个封装了vector<string> 的类。该类有一个重载的operator[]，可用于读取和修改向量的内容。这是它的外观（最低限度）：

class ReverseStringAccess {
    public:
        ReverseStringAccess() {}
        ReverseStringAccess(vector<string> _arr) arr(_arr) {}
        string& operator[](int index) {
            return arr[index];
        }
    private:
        vector<string> arr;
};

现在我需要能够修改向量中每个字符串的内容，而无需直接访问向量（即某种operator[][]，它只适用于属于此类成员的向量）。问题是使用ReverseStringAccess[][] 将导致operator[] 在字符串上的默认行为。比如这个语句：

ReverseStringAccess[i][j]

将给出向量中第 i^th 字符串的 j^th 字符。但我希望它（例如）改为获取向量中 i^th 字符串的 (length - j - 1)^th 字符，其中 length 是第 i^th 字符串的长度。

这可能吗？如果是，怎么做？

Answer 1

如果您希望my_object[i][k] 不调用std::string::operator[]，则不要从MyClass::operator[] 返回std::string&，而是实现所需[] 的代理：

class MyClass {
    public:
        MyClass() {}
        MyClass(vector<string> _arr) arr(_arr) {}

        struct MyProxy {
             std::string& str;
             char& operator[](size_t index) { /.../ }
             const char& operator[](size_t index) const { /.../ }
        };

        MyProxy operator[](int index) {
            return {arr[index]};
        }
    private:
        vector<string> arr;
};

Answer 2

问题是如何通过[][]对vector<string>的成员实现反向索引。

这可以通过 std::string 的包装类来实现：

template<typename T>
class reverse_access {
    T& ref;
public:
     // create wrapper given reference to T
     reverse_access(T& ref_)
         : ref(ref_)
     {}

     // reverse access operator []
     auto operator[](size_t i) -> decltype(ref[0])
     { return ref[ ref.size() - 1 - i]; }
     auto operator[](size_t i) const -> decltype(ref[0])
     { return ref[ ref.size() - 1 - i]; }

      // allow implicit conversion to std::string reference if needed
     operator T&() { return ref; }
     operator const T&() const { return ref; }
};

// inside MyClass:
        reverse_access<string> operator[](int index) {
            return reverse_access<string>(arr[index]);
        }
        reverse_access<const string> operator[](int index) const {
            return reverse_access<const string>(arr[index]);
        }

并在 MyClass 中的 operator[] 中使用 return reverse_access<std::string>(arr[index]);。 添加的转换运算符允许隐式转换为对原始类型的引用。

另一种选择是使用可以接受 2 个参数的不同运算符：myclass(vec_index,str_index):

        string::reference operator()(size_t vec_index, size_t str_index)
        {
            return arr[vec_index][ arr[vec_index].size() - str_index ];
        }
        string::const_reference operator()(size_t vec_index, size_t str_index) const
        {
            return arr[vec_index][ arr[vec_index].size() - str_index ];
        }

第三种解决方案是在构造 ReverseStringAccess 时反转所有字符串：

ReverseStringAccess(vector<string> _arr) arr(_arr) 
{
   for (auto& str : arr)
       std::reverse(str.begin(), str.end());
}