Question

所以，我有这样的课程：Matrix和Matrix_Proxy。两者都应该检查范围是否有效，但在这里我省略了，因为那不是问题。

只要对象是非常量的，它就没问题，但是不会这样做。按const&发送函数参数是有效的做法，因此它失败了。

代码（简化）：

#include <vector>
#include <cstdlib>
#include <iostream>

template <typename T>
class Matrix_Proxy
{
public:
    Matrix_Proxy(std::vector<T>& _ref, size_t _size) : ref(_ref), size(_size)
    {}
    T& operator[](int i)
    {
        return ref[i];
    }

    const T& operator[](int i) const
    {
        return ref[i];
    }

private:
    std::vector<T>& ref;
    size_t size;

};

template <typename T>
class Matrix
{
public:
    Matrix(size_t x) : values(x), size(x)
    {
        for(auto&& y : values)
        {
            y.resize(x);
            for(auto&& x : y)
                x = 0;
        }
    }

    Matrix_Proxy<T> operator [] (int i)
    {
        return Matrix_Proxy<T>(values[i],size);
    }

    const Matrix_Proxy<T> operator [] (int i) const
    {
        return Matrix_Proxy<T>(values[i],size);
    }

private:
    std::vector<std::vector<T>> values;
    size_t size;
};

int main()
{
    Matrix<int> intMat(5);                    //FINE
    std::cout << intMat[2][2] << std::endl;   //FINE

    const Matrix<int> cintMat(5);             //FINE
    std::cout << cintMat[2][2] << std::endl;  //ERROR

    _Exit(EXIT_SUCCESS);
}

错误：

no matching function for call to 'Matrix_Proxy<int>::Matrix_Proxy(const value_type&, const size_t&)'
         return Matrix_Proxy<T>(values[i],size);
                                              ^

有任何想法如何解决这个问题？

Answer 1

问题的根本原因是您的代理允许非const访问，即使代理本身是通过const运算符生成的。换句话说，如果您的代码可以编译，则允许这样做：

const Matrix<int> cintMat(5);
cintMat[2][2] = 2; // Does not compile

这是因为从Matrix_Proxy生成的operator [] const同时包含operator [] const和operator []非const。您的Matrix_Proxy不知道它是通过const运算符生成的！

要解决此问题，请引入另一个代理，并从const运算符[]返回：

template <typename T>
class Matrix_Proxy_Const
{
public:
    Matrix_Proxy_Const(const std::vector<T>& _ref, size_t _size) : ref(_ref), size(_size)
    {}
    const T& operator[](int i) const {
        return ref[i];
    }
private:
    const std::vector<T>& ref;
    size_t size;
};

在Matrix班级中更改const运算符实现：

const Matrix_Proxy_Const<T> operator [] (int i) const {
    return Matrix_Proxy_Const<T>(values[i],size);
}

Demo.

运算符[]错误的Matrix类代理

1 个答案: