C++: advanced class model for matrix calculator - c++

Question

I'm making a matrix calculator as a project for my C++ class in college and I'm not sure how to design the classes for it. My problem is that one of the traits of this program has to be that sparse and dense matrices should be stored in different ways for memory efficiency (dense as typical 2D array or vector, sparse in CSR format for example), but I need to handle both of the types in same way.
So far I was thinking of something like have abstract class 'MatrixWrapper', which should contain all the shared algorithms for adding, multiplying, GEM, and so on. And then have classes 'MatrixDense' and 'MatrixSparse', which would both inherit from 'MatrixWrapper' and therefor have same interface (shown in code below). But that's where I got stuck, because with this approach when I tried implementing the algorithms in 'MatrixWrapper' I didn't know with which of the two matrices I'd be working. I'm just not sure how to solve this or even may approach is correct.
class MatrixWrapper {
public:
// shared algorithms
/* for example
void addMatrix ( const ??? &x ) {
...
}
*/
}
class MatrixDense : public MatrixWrapper {
public:
//constructor, destructor, ...
private:
vector< vector<double> > matrix;
}
class MatrixSparse : public MatrixWrapper {
public:
//constructor, destructor, ...
private:
struct CSR {
...
};
CSR matrix;
}
I was maybe thinking about adding 2D array to the 'MatrixWrapper' along side with abstract method setValue() and then in 'MatrixSparse' and 'MatrixDense' every time just setting the values of this array using this method and then just working with that 2D array in 'MatrixWrapper', but I'm not sure how to implement that or even if that's the right approach.

Answer 1

Implement all binary operators using non-member functions. Either global functions, or functions inside an unrelated class:
// Option 1
void add(
MatrixWrapper& result,
const MatrixWrapper& operand1,
const MatrixWrapper& operand2);
// Option 2
struct WrapperForMatrixOperations // I don't know why you might want this class to exist
{
static // or maybe not static
void add(
MatrixWrapper& result,
const MatrixWrapper& operand1,
const MatrixWrapper& operand2);
};
The reason is, your algorithm will probably return a "dense" matrix when adding a dense and a sparse matrix:
dense + sparse = dense
sparse + sparse = sparse
sparse + dense = dense <- problem!
dense + dense = dense
This cannot work if it is implemented as a non-const member function.
You should also decide how you want to create your matrices - maybe each binary operation should allocate a new matrix and return it by shared_ptr?