Parameter of member functions of template class

Question

I am trying to better understand templates and have turned to to the good 'ole matrix class. I know about eigen, armadillo, etc. my purpose is to better understand templates. My question is how do you get a member function to take an argument that is an object of the same template class, but with a different specialization?

For example, the matrix class I'm trying to put together takes two template parameters--number of rows and number of columns. Also, any m x n matrix object (Matrix<mRows,nCols>) should be able to take an n x p matrix object (Matrix<nCols,pCols>) and multiply them together and return an m x p matrix object (Matrix<mRows,pCols>):

template <unsigned mRows, unsigned nCols>
class Matrix
{
private:
    double matrixData[mRows][nCols];
 //...other stuff
public:
 //...other stuff

   Matrix operator * (const Matrix<nCols, pCols>& rhs);
}

// simple naive matrix multiplication method
template <unsigned mRows, unsigned nCols>
Matrix<nCols,pCols> Matrix<mRows, nCols>::operator * (const Matrix<nCols,pCols>& rhs)
{
    Matrix<nCols,pCols> temp();

    for (int r = 0; r<mRows; ++r)
    {
        for(int c = 0;c<pCols;++c)
        {
            temp.matrixData[r][c]=0;
            for (int elem = 0; elem<nCols;++elem)
            {
                temp.matrixData[r][c]+= matrixData[r][elem]*rhs.matrixData[elem][c];
            }
        }
    }

    return temp;
}

The main function would be something like:

int main() 
{
  Matrix<2,3> m1;
  Matrix<3,4> m2;

  //...initialize matrices...

  Matrix<2,4> m3 = m1 * m2;

}

This doesn't work because pCols isn't declared anywhere. Where / how should it be declared?

Answer 1

So after messing with this for a while I finally have a solution using suggestions from Columbo. The first solution keeps the multiplication operator as a member function and then makes all specializations friends with each other so they can modify each others private data:

template <unsigned mRows, unsigned nCols>
class Matrix
{
private:
    double matrixData[mRows][nCols];

public:

    template<unsigned nRows, unsigned pCols> // make all specializations of the templates friends with each other
    friend class Matrix;

    // ... constructor and other operator definitions/prototypes here

    // define proper matrix multiplication
    // should be defined such that Matrix<mRows,pCols> = Matrix<mRows,nCols>*Matrix<nCols*pCols> 
    // since the inner dimensions of the matrix must be the same.
    template <unsigned pCols>
    Matrix<mRows,pCols> operator * (const Matrix<nCols, pCols>& rhs) const;
};

template <unsigned mRows, unsigned nCols>
template <unsigned pCols>
Matrix<mRows,pCols> Matrix<mRows, nCols>::operator * (const Matrix<nCols,pCols>& rhs) const
{
    Matrix<mRows,pCols> temp;

    for (unsigned r = 0; r<mRows; ++r)
    {
        for(unsigned c = 0;c<pCols;++c)
        {
            temp.matrixData[r][c]=0;
            for (unsigned elem = 0; elem<nCols;++elem)
            {
                temp.matrixData[r][c]+= matrixData[r][elem]*rhs.matrixData[elem][c];
            }
        }
    }

    return temp;
}

The second solution follows Columbo's suggestion to make the multiplication operator a friend non-member function:

template <unsigned mRows, unsigned nCols>
class Matrix
{
private:
    double matrixData[mRows][nCols];

public:

    // ... constructor and other operator definitions/prototypes here

    // define proper matrix multiplication
    // should be defined such that Matrix<mRows,pCols> = Matrix<mRows,nCols>*Matrix<nCols*pCols> 
    // since the inner dimensions of the matrix must be the same.

    template <unsigned m, unsigned n, unsigned p>
    friend Matrix<m,p> operator * (const Matrix<m,n>& lhs, const Matrix<n, p>& rhs);
};

template <unsigned m, unsigned n, unsigned p>
Matrix<m,p> operator * (const Matrix<m,n>& lhs, const Matrix<n, p>& rhs)
{
    Matrix<m,p> temp;

    for (unsigned r = 0; r<m; ++r)
    {
        for(unsigned c = 0;c<p;++c)
        {
            temp.matrixData[r][c]=0;
            for (unsigned elem = 0; elem<n;++elem)
            {
                temp.matrixData[r][c]+= lhs.matrixData[r][elem]*rhs.matrixData[elem][c];
            }
        }
    }

    return temp;
}

If anyone could comment on why one is better than the other it'd be great. I think the second solution is better since just that function is specialized for different combinations instead of the entire class (right?). For example in Matrix<3,3> * Matrix<3,4> vs Matrix<3,3> * Matrix<3,5> the Matrix<3,3> class would only need to specialized once and the * operator would be specialized to cover both cases. Right?

Answer 2

The operator* function needs only one template parameter. The number of rows of the RHS has to be the same as the number of columns of the LHS.

template <unsigned pCols>
Matrix<nRows, pCols> operator * (const Matrix<nCols, pCols>& rhs)
{
  //...
}

Answer 3

Make operator* a member function template himself. I.e. write inside the class template

template <unsigned pCols>
Matrix operator * (const Matrix<nCols, pCols>& rhs);

And outside use two parameters lists:

template <unsigned mRows, unsigned nCols>
template <unsigned pCols>
Matrix<mRows, pCols> Matrix<mRows, nCols>::operator * (const Matrix<nCols,pCols>& rhs)

However, I encourage you to use a friend non-member function.

Answer 4

You have to use template arguments available in your function template definition to specialize the Matrix class, in your case:

template <unsigned mRows, unsigned nCols>
Matrix<mRows,nCols> Matrix<mRows, nCols>::operator * (const Matrix<nCols,mRows>& rhs)

Then again you're better off using a consistent naming convention for your template arguments in both declaration and definition.

Think of the template arguments as of types/constants available for you to use within the entity that follows it. Declarations are definitions are essentially separate entities in this context (that's why you need to type template<> second time when providing a function definition).

Edit: After reading the question once again carefully, it turns out my answer misses the point. Columbo's answer is the way to go.