C++中如何实现协变参数类型

Question

I'm trying to write a matrix class interface, and then create specific implementations for each kind of matrix (eg row-major, col-major, sparse version etc), the problem is that the interface defines the math operations using the IMatrix class, but if i use the derived classes instead in the overriden methods it just fails to compile (since i guess in C++ covariant types only work for return types right ?).

class IMatrix
{
    int rows, cols, count;
public:
    virtual ~IMatrix() = 0;
    virtual IMatrix& plus(IMatrix& matrix) = 0;
};

class RMMatrix: public IMatrix // row-major matrix implementation
{
    long double* data;
public:
    ~IMatrix() { delete[] data };
    RMMatrix& plus(IMatrix& matrix) override // this works but then i cannot access matrix.data
    {
        // do addition
    }
};

So basically I'd like to be able to override using this function signature:

RMMatrix& plus(RMMatrix& matrix) override // fails because function signature differs from IMatrix

As i've said before, i'm new to OOP C++ and i can't seem to figure out the right way to enforce implementation classes (eg RMMatrix and other derived classes) to define these methods without using a pure virtual in the interface and without dynamic_cast =o I thought about using templates, and giving the derived implementation class as an argument but that feels weird =s

Answer 1

I'm not sure, so i'm just posting it here to make sure if this is a valid answer (for others to review) based on @n.'pronouns'm 's feedback.

template<class Derived>
class Matrix
{
    int rows, cols, count;
public:
    virtual Derived& plus(Derived& matrix) = 0;
};


class RMMatrix: public Matrix<RMMatrix>
{
    long double* data;
public:
    ~RMMatrix() { delete[] data; };
    RMMatrix& plus(RMMatrix& matrix) override 
    { 
        // do something
    }

};

Edit: As stated in the comment, since Matrix is not an abstract class i can just remove the destructor and it compiles correctly