模板矩阵类中的operator *的多重重载

Question

I have a template class of myMatrix mainly like:

template<class T, int row, int col>
class myMatrix{
   T *_mat;
public:
   template<int r, int c> using matrix_t = T[r][c];
   myMatrix(const matrix_t<row, col> &);
   myMatrix(const myMatrix<T, row, col> &);
   myMatrix &operator=( const myMatrix<T, row, col>& );
   //...
   // next is the part of * overloading
   myMatrix<T, row, col> operator*(const T& scalar);
   typename< int c2 >
   myMatrix<T, row, c2> operator*( const myMatrix<T, col, c2>& );
   typename< int c2 > 
   myMatrix<T, row, c2> operator*( const matrix_t<col, c2>& );
   typename< int r2 > 
   friend myMatrix<T, r2, col> operator*( const matrix_t<r2, row>&, const myMatrix<T, row, col>& );
   // ...
};

Then I design another class Reference :

template<int dim, int loop>
class Reference{
    myMatrix<int, dim, loop> _matA;
    myMatrix<int, dim, 1> _matC;
public:
    Reference(const myMatrix<int, dim, loop> &, const Matrix<int, dim, 1> &);
    Reference(const Reference<dim, loop> &);
    Reference<dim, loop> &operator=(const Reference<dim, loop> &);
    // ...
    friend Reference<1, loop> operator*(const Matrix<int, 1, dim> &alpha,
           const Reference<dim, loop> & ref)
    {
       return Reference(alpha * ref._matA, alpha * ref._matC);  // **Problem!!!**
    }
    // ...
};

When I test the codes with something like

    const int matA[3][3] = {1,2,3,4,5,6,7};
    const int matC[3][1] = {1,2,3};
    const int alp[][3] = {1,2,2};
    Reference<3,3> ref(matA, matC);
    Matrix<int, 1, 3> alpha(alp);
   // Reference<1,3> ref_t = alp * ref;
    Reference<1,3> ref_t = alpha * ref; // **can not compile!!!**

The problem occurs:

binary '*': no operator found which takes a left-hand operand of type 'const myMatrix' ( or there is no acceptable conversion )...

Then here come my questions:

1. Of all the +4 overloadings in class myMatrix , if there are any redundancies?

2. Maybe just the overloading version of typename< int c2 > myMatrix<T, row, c2> operator*( const myMatrix<T, col, c2>& ); can service the following two overloads since a built-in 2d-array like arr[][] can convert to a myMatrix due to my constructor myMatrix(const matrix_t<row, col> &); ?

3. What is the reason for the compiling error?

Answer 1

The compiler error says what you've done wrong:

binary '*': no operator found which takes a left-hand operand of type 'const myMatrix'

You have

operator*(const myMatrix&);

but no

operator*(const myMatrix&) const;

So alpha * ref can't match (because alpha is const& ).

The usual way to implement T::operator* is

T& operator*=(const T&);
T operator*(const T&) const;

Or (better), make the * operator a free function with two arguments (this can work better if you might need to promote the left-hand argument).