Question

I am developing a matrix class for my personal library. I am using a template class (Class T) because I want a matrix to be of any numeric or boolean format (and don’t want to retype everything). So what I would like to do is have the operater+= allow a scalar or a matrix. However, I would like to be able to add two matrices together regardless of their numeric format (Class U).

I get the following compile errors.

error: prototype for 'JecMatrix<T>& JecMatrix<T>::operator+=(const JecMatrix<U>&)' does not match any in class 'JecMatrix<T>'
error: candidates are: template<class T> template<class U> JecMatrix& JecMatrix::operator+=(const U&)
error:                 template<class T> template<class U> JecMatrix& JecMatrix::operator+=(const JecMatrix<U>&)

Does anyone have a solution to this? I’ve included the entire class below.

#ifndef JECMATRIX_H
#define JECMATRIX_H

#include <typeinfo>

#include <QTime>
#include <QList>

#include <JecLibrary_global.h>
#include <JecUtils.h>

template<class T>
class JECLIBRARYSHARED_EXPORT JecMatrix
{
public:
    JecMatrix();
    JecMatrix(const int& rows, const int& cols);
    JecMatrix(const QList<QList<T> >& sourceMatrix);

    ~JecMatrix();

    JecMatrix<T>& operator=(const JecMatrix<T>& rhs);
    bool operator!=(const JecMatrix<T>& rhs) const;
    bool operator==(const JecMatrix<T>& rhs) const;

    template<class U> JecMatrix<T>& operator+=(const JecMatrix<U> &rhs) throw(QString);
    template<class U> JecMatrix<T>& operator+=(const U& rhs) throw(QString);

};

template<class T>
JecMatrix<T>::JecMatrix()
{
    T var;
    assertNumber(var);
}

template<class T>
JecMatrix<T>::JecMatrix(const int &rows, const int &cols)
{
    for (int r = 0; r < rows; ++r)
    {
        matrix.append(QList<T>());
        for (int c = 0; c < cols; ++c)
        {
            matrix[r].append(0);
        }
    }
}

template<class T>
JecMatrix<T>::JecMatrix(const QList<QList<T> >& sourceMatrix)
{
    for (int r = 0; r < sourceMatrix.length(); ++r)
    {
        matrix.append(QList<T>());
        for (int c = 0; c < sourceMatrix.at(r).length(); ++c)
        {
            matrix[r].append(sourceMatrix.at(r).at(c));
        }
    }
}

template<class T>
JecMatrix<T>& JecMatrix<T>::operator=(const JecMatrix<T>& rhs)
{
    if (this == &rhs)
    {
        return *this;
    }


    this->id = rhs.id;                          // The id of the Base.

    this->minerals = rhs.minerals;              // The minerals available at that base.
    this->vespene = rhs.vespene;                        // The gas available at that base.

    this->buildings = rhs.buildings;            // The units the player owns during this second. The outer QList holds the types of units and the inner holdes the unique coppies of that unit.
    this->units = rhs.units;                    // The units the player owns during this second. The outer QList holds the types of units and the inner holdes the unique coppies of that unit.

    return *this;
}


template<class T,class U>
JecMatrix<T>& JecMatrix<T>::operator+=(const JecMatrix<U> &rhs) throw(QString)
{
    // Perform type checking.
    U var;
    assertNumber(var);

    // Perform size checking.
    if (rhs.getRows() != getRows()) {
        throw ("To add the matrices they must have the same number of rows and columns.  Matrix a has "
                    + QString::number(a.getRows())
                    + " rows and matrix b has "
                    + QString::number(b.getRows()) + " rows.");
    }

    if (rhs.getCols() != getCols()) {
        throw ("To add the matrices they must have the same number of rows and columns.  Matrix a has "
                    + QString::number(a.getCols())
                    + " cols and matrix b has "
                    + QString::number(b.getCols()) + " cols.");
    }

    double result[][] = new double[a.getRows()][a.getCols()];

    // Add the matrices.
    for (int resultRow = 0; resultRow < a.getRows(); resultRow++) {
        for (int resultCol = 0; resultCol < a.getCols(); resultCol++)
        {
            matrix[resultRow][resultCol] += rhs.matrix[resultRow][resultCol];
        }
    }

    return *this;
}

template<class T, class U>
JecMatrix& JecMatrix::operator+=(const U& rhs) throw(QString)
{
    // Perform type checking.
    U var;
    assertNumber(var);

    // Perform the scalar addition.
    for (int r = 0; r < matrix.length(); ++r)
    {
        for (int c = 0; c < matrix.at(0).length(); ++c)
        {
            matrix[r][c] += rhs;
        }
    }
}


#endif // JECMATRIX_H

Edit: removed irrelevant code.

Answer 1

Say it like this:

template <class T>
template <class U>
JecMatrix<T>& JecMatrix<T>::operator+=(const JecMatrix<U> &rhs) throw(QString)
{
    // ...
}

The two template declarations have to be separate.