C++11 Cannot cast template inheritance - c++

Question

I'm writing the Math module for an OpenGLES project.
I wrote a class for managing float matrices for a generic size
template <unsigned int N>
class MatrixN {
public:
float m[N*N];
MatrixN(){}
virtual ~MatrixN(){}
void identify();
MatrixN& operator=(const MatrixN& b);
};
template <unsigned int N>
MatrixN<N> operator*(const MatrixN<N>& a, const MatrixN<N>& b);
//CPP file implementation
template<unsigned int N>
MatrixN<N> operator*(const MatrixN<N>&a, const MatrixN<N> &b) {
MatrixN<N> matrix;
for(unsigned int i = 0; i < N; i++){
for(unsigned int j = 0; j < N; j++){
matrix.m[i * N + j] = 0;
for(unsigned int z = 0; z < N; z++){
matrix.m[i * N + j] += a.m[i * N + z] * b.m[z * N + j];
}
}
}
return matrix;
}
And the i create a sub-class for managing 3x3 matrices
class Matrix3 : public MatrixN<3> {
public:
void rotateX(const float radians);
void rotateY(const float radians);
void rotateZ(const float radians);
};
Why when i perform this operation
//Rotations instances of Matrix3
Matrix3 rotation = this->rotation * input.rotation;
i get this error at compile time?
no viable conversion from 'MatrixN<3U>' to 'const Matrix3'

Answer 1

It's because the multiply operation return MatrixN<3> and is not Matrix3
In this case, you can create a constructor in Matrix3 that accept MatrixN<3>
code (not tested) :
class Matrix3 : public MatrixN<3> {
public:
Matrix3 (const MatrixN<3>& mat){/*set internal values*/}
void rotateX(const float radians);
void rotateY(const float radians);
void rotateZ(const float radians);
};

Answer 2

The problem is that the result type of operator* is MatrixN<N> but the type of rotation is Matrix3 and the implicit cast does not work because this would be a downcast.
As a possible solution you can overwrite the operator* for Matrix3 inputs and outputs. With a helper function you can spare some code if you would like to reuse it. For example:
template< MatrixType >
MatrixType multiple(const MatrixType& a, const MatrixType& b, size_t N )
{
MatrixType matrix;
for(unsigned int i = 0; i < N; i++)
{
for(unsigned int j = 0; j < N; j++)
{
matrix.m[i * N + j] = 0;
for(unsigned int z = 0; z < N; z++)
{
matrix.m[i * N + j] += a.m[i * N + z] * b.m[z * N + j];
}
}
}
return matrix;
}
Matrix3 operator*(const Matrix3& a, const Matrix3& b)
{
return multiple< Matrix3 >( a, b, 3 );
}
Note that this can be a bit dangerous because there is not any protection to avoid overflow, so the "user" of the multiple function should be careful.

Answer 3

Your multiplication operator is implemented in terms of MatrixN<N>. Your derived type Matrix3 isn't immediately one of those but has one of those as base. So there is still a derived to base conversion to call the operator and the type returned isn't immediately the type you want.
You can define your multiplication operator to take any type as arguments and return this type and then constrain it to only really take types which are derived from MatrixN<N>:
template<typename Matrix,
typename = std::enable_if_t<std::is_base_of<MatrixN<Matrix::size>, Matrix>::value>>
Matrix operator*(const Matrix&a, const Matrix &b) {
constexpr unsigned N = Matrix::size;
Matrix matrix;
for(unsigned int i = 0; i < N; i++){
for(unsigned int j = 0; j < N; j++){
matrix.m[i * N + j] = 0;
for(unsigned int z = 0; z < N; z++){
matrix.m[i * N + j] += a.m[i * N + z] * b.m[z * N + j];
}
}
}
return matrix;
}
To statically determine the size N of the matrix, the class template needs to have a nested constant expression value size, e.g.:
template <unsigned int N>
class MatrixN {
public:
static constexpr unsigned int size = N;
// ...
};

Answer 4

This code may work. But you should know this is very very dangerous.
MatrixN<3> tmp_scoped_var = this->rotation * input.rotation;
Matrix3 &rotation = reinterpret_cast<Matrix3 &>(tmp_scoped_var);
rotation.rotateX(1.1); // Call the method of B
Because tmp_scoped_var hold the data returned by MatrixN<N> 's operator *. So the memory will be freed while out of the scope. This code tells the compile to force using Matrix3 's method on the MatrixN<N> variable. The memory layouts of Matrix3 and MatrixN<N> are identical, otherwise, the program may crash due to segment fault.
According to you code, you may desire to add some particular method while the template parameter N equals 3. So class template specialization could be used.
template <>
class MatrixN<3> {
public:
float m[3*3];
MatrixN(){}
virtual ~MatrixN(){}
void identify();
MatrixN& operator=(const MatrixN<3>& b);
public:
void rotateX(const float radians);
void rotateY(const float radians);
void rotateZ(const float radians);
};