Question

假设：

class example
{
    public:
        std::vector<std::vector<int>> a;
        int b;
}

func()
{
    example e;
    ... // populate e

然后我可以使用像这样的示例成员。

    int n = e.b;
    int n2 = e.a[2][3];

但是，我可以选择覆盖[]运算符。

    int n = e.b;
    int n2 = e[2][3];
}

编辑：抱歉，该示例现已修复。

Answer 1

您可以做的是重载访问运算符并将其委托给向量：

class example
{
    public:
        std::vector<std::vector<int>> a;
        int b;

        const std::vector<int>& operator[](std::size_t i) const
        {
            return a[i];
        }
        std::vector<int>& operator[](std::size_t i)
        {
            return a[i];
        }
};

然后，第一个[]将返回对a各个元素的引用，其中将使用第二个[]。

Answer 2

一个天真的解决方案是定义自己的operator[]：

class example
{
    std::vector<std::vector<int>> v;
public:
    std::vector<int> const & operator[](std::size_t i) const { return v[i]; }
    std::vector<int>       & operator[](std::size_t i)       { return v[i]; }

    // ...
};

现在，如果你有example e;，那么e[1]就是一个int的向量，等等。

看起来你想写一些矩阵类。为此，只需一个向量并大步访问它就会更有效：

class Matrix
{
    std::size_t cols;
    std::size_t rows;
    std::vector<int> v;

public:
    explicit Matrix(std::size_t r, std::size_t c) : cols(c), rows(r), v(r*c) { }

    int operator()(std::size_t i, std::size_t j) const { return v[i * cols + j]; }
    int & operator()(std::size_t i, std::size_t j) { return v[i * cols + j]; }
};

现在你可以说：Matrix m(4, 7); m(1, 3) = 8;。你必须使用圆括号运算符，因为square-bracket运算符必须始终采用一个参数，因此不适用于此。

C ++有选择地重载[]？

2 个答案: