无法重载嵌套数组<array <float，n>，m>

如何解决无法重载嵌套数组<array <float，n>，m>

我创建了一个简单的矩阵定义，如下所示：

template <size_t m,size_t n>
using Matrix = boost::array<boost::array<float,n>,m>;

我希望重载[]​​运算符，以便可以使用matrix[i,j]而不是matrix[i][j]访问矩阵值。我尝试了以下操作，但无济于事。

template <size_t m,size_t n>
float& Matrix<m,n>::operator[](uint32_t i,uint32_t j) {
    return &(this[i][j]);

我无法理解模板的部分专业化，并且通常不理解为什么我不能重载运算符。

clang ++ 10.0.1的编译输出为

matri.cpp:10:21: error: nested name specifier 'Matrix<m,n>::' for declaration does not refer into a class,class template
 or class template partial specialization
float& Matrix<m,uint32_t j) {
       ~~~~~~~~~~~~~^
matri.cpp:11:14: error: invalid use of 'this' outside of a non-static member function
    return &(this[i][j]);
             ^
matri.cpp:11:19: error: use of undeclared identifier 'i'
    return &(this[i][j]);
                  ^
matri.cpp:11:22: error: use of undeclared identifier 'j'
    return &(this[i][j]);

解决方法

此方法存在多个问题。

• 由于Matrix仅是别名，因此您试图部分专门化operator[]的成员函数（boost::array），但是只能部分化整个类模板，而不仅仅是成员函数。

• operator[]是二进制的（仅一个操作数必须在方括号内），并且在用户定义的类中重载时该值不能更改。如果您不喜欢链接那些运算符，则可以重载operator()。

下面显示了用户定义的Matrix类的最小实现。如果需要更多功能，请考虑使用一个已经存在的线性代数库。

#include <array>
#include <initializer_list>
#include <iostream>
#include <numeric>

template <class Type,size_t Rows,size_t Cols>
class Matrix
{
    std::array<Type,Rows * Cols> m_;
public:
    Matrix() = default;
    Matrix(std::initializer_list<std::initializer_list<Type>> src) {
        auto dest{ m_.begin() };
        for ( auto const& row : src ) {
            std::copy(row.begin(),row.end(),dest);
            dest += Cols;
        }
    }
    static constexpr size_t rows() {
        return Rows;
    }
    static constexpr size_t columns() {
        return Cols;
    }
    auto begin() {
        return m_.begin();
    }
    auto begin() const {
        return m_.begin();
    }
    auto end() {
        return m_.end();
    }
    auto end() const {
        return m_.end();
    }
    Type operator() (size_t i,size_t j) const { 
        return m_[i * Cols + j];
    }
    Type& operator() (size_t i,size_t j) { std::cout << '*';
        return m_[i * Cols + j];
    }
};

template< class T,size_t R,size_t C >
std::ostream& operator<< (std::ostream& os,Matrix<T,R,C> const& m) {
    for ( size_t i{}; i < R; ++i ) {
        for ( size_t j{}; j < C; ++j ) {
            os << ' ' << m(i,j);
        }
        os << '\n';
    }
    return os;
}

int main() {
    Matrix<float,3,4> a{};
    std::iota(a.begin(),a.end(),1);
    std::cout << a << '\n';

    Matrix<double,4> b {
        {1,4,7,10},{2,5,8,11},{3,6,9,12}
    };
    std::cout << b << '\n';
}