事情是这样的。我写了如下的代码（已简化）：

class Mat {
private:
    int a[maxn][maxn];
public:
    int* operator[] (int q) {
        return a[q];
    }
    Mat operator* (const Mat &q) const {
        Mat res;
        res[1][1] = a[1][1] * q[1][1];  // CE
        return res;
    }
};

此时，会在 p 处报 CE，原因是我的 q 是一个引用的参数，只能调用其 const 函数。于是，我试着为 operator[] 加上 const 修饰：

class Mat {
private:
    int a[maxn][maxn];
public:
    int* operator[] (int q) const { // Here
        return a[q]; // CE
    }
    Mat operator* (const Mat &q) const {
        Mat res;
        res[1][1] = a[1][1] * q[1][1];
        return res;
    }
};

但是因为 const 的修饰，此时的 a[i] 被强制转换为了 const int* 类型，与函数返回值 int* 不匹配。

那如果在返回值前加上 const 限定符呢？

class Mat {
private:
    int n, m;
    int a[maxn][maxn];
public:
    const int* operator[] (int q) const { // Here
        return a[q];
    }
    Mat operator* (const Mat &q) const {
        Mat res;
        res[1][1] = a[1][1] * q[1][1]; // CE
        return res;
    }
};

此时 res[1][1] 是一个 const 类型。不是一个可修改的左值。

我能想到的唯一一个解决方案如下：

class Mat {
private:
    int n, m;
    int a[maxn][maxn];
public:
    const int* operator[] (int q) const {
        return a[q];
    }
    Mat operator* (const Mat &q) const {
        Mat res, t(q); // Here
        res[1][1] = a[1][1] * t[1][1];
        return res;
    }
};

但这样做明显违背了我将 q 作为引用变量传参加速的初衷（虽然我后面是一个 n 立方的矩乘 n 方传参加速加了个寂寞而且还有另一个更重要的原因是不用引用参数太大了会 CE）。

所以是否有其他解决方案，让我可以直接使用 q[1][1] 的值？