Creating a derived class object inside of base class object - c++

Question

I'm implementing matrices according to the strategy pattern.
for that I have MyMatrix, which holds a pointer to Matrix, and two subclasses that inherit from Matrix - SparseMatrix & RegMatrix.
when adding two matrices, because I can't know which matrix I'm adding to which matrix, I implemented a base function which uses an inner method of each inheriting class, and when adding - I just add the new elements to the lefthand matrix.
This works fine.
my problem is - I now want to perform matrix multiplication.
I want to implement this method in the base class - Matrix.
this is what I have until now:
Matrix& multiple(Matrix &other)
{
double result = 0;
int newMatrixRowSize = getRowSize();
int newMatrixColSize = other.getColSize();
double *resultArray = new double[newMatrixRowSize*newMatrixColSize];
for (int i = 1; i <= getColSize(); i++)
{
for (int j = 1; j <= other.getColSize(); j++)
{
for (int k = 1; k <= other.getRowSize(); k++)
{
Pair firstPair(i,k);
Pair secondPair(k,j);
result += getValue(firstPair)*other.getValue(secondPair);
}
Pair resultIndex(i,j);
resultArray[getNumIndex(resultIndex, newMatrixRowSize, newMatrixColSize)] = result;
result = 0;
}
}
delete [] resultArray;
}
only problem is, now I can't just add the new elements to the lefthand matrix, I have to create a new RegMatrix or SparseMatrix, and according to the number of zeros in the matrix - swap to the legit representation of matrix.
so my question is - is it "legal" or good practice to create an instance of the base class' derived class inside the base class?
I want to avoid using the factory pattern, and more willing to do something polymorphic without knowing the kind of matrix in hand

Answer 1

You have to use a factory if you want to create objects of different types depending on condition. If you don't want Matrix to know about its descendants, you have several options. Apart from implementations using interfaces, in C++11 you can use std::function:
class Matrix {
typedef std::function<Matrix*(const double*, int, int)> Factory;
Factory factory;
public:
Matrix(const Factory& f) : factory(f) {}
Matrix* multiple(Matrix &other) {
....
return factory(resultArray, newMatrixRowSize, newMatrixColSize);
}
};
It gives you the advantage that you can pass any function-like object as a factory:
Matrix* matrixFactoryFunc(const double* data, int rowSize, int colSize) {
return nullptr;
}
class MatrixFactoryCallable {
public:
Matrix* operator()(const double* data, int rowSize, int colSize) {
return nullptr;
}
};
class MatrixFactoryWithMemFun {
public:
Matrix* createMatrix(const double* data, int rowSize, int colSize) {
}
};
void testFactory() {
std::function<Matrix*(const double*, int, int)> factory;
factory = matrixFactoryFunc;
factory = MatrixFactoryCallable();
MatrixFactoryWithMemFun mi;
factory = std::bind(&MatrixFactoryWithMemFun::createMatrix, &mi, _1, _2, _3);
Matrix m(factory);
}