基于CRTP的Matrix类二进制运算符重载

如何解决基于CRTP的Matrix类二进制运算符重载

我有一个基于CRTP的矩阵库，并且想对所有类型的矩阵（静态，动态和“ pseudo_dynamic”（编译时已知的最大大小））通用一些二进制运算符重载

下面是一个最小的库示例：

#include <cstdlib>
#include <cassert>

template<class T,class Derived>
class Matrix_Base
{
public:

    // How to implement these binary operators for all types of Derived?
    Derived operator+(const Derived &other) const;

    Derived& operator+=(const Derived &rhs);

    Derived operator-(const Derived &other) const;

    Derived operator*(const Derived &rhs) const;

    inline Derived& get_this() const { return (Derived&)*this; }
};

template <class T>
class Dynamic_Matrix : public Matrix_Base<T,Dynamic_Matrix<T>> 
{
private:
    size_t n_rows,n_cols;

    T* data;

    bool is_allocated;

    void allocate_data()
    {
        assert(n_rows > 0 && n_cols > 0);
        data = new T[n_rows * n_cols];
        is_allocated = true;
    }

    void deallocate_data() { delete[] data; data = nullptr; is_allocated = false; }

public:
    
    Dynamic_Matrix() : n_rows(0),n_cols(0),data(nullptr),is_allocated(false) {}

    Dynamic_Matrix(const size_t n_rows,const size_t n_cols) :
    n_rows(n_rows),n_cols(n_cols),is_allocated(false)
    {
        allocate_data();
    }

    ~Dynamic_Matrix() { deallocate_data(); }

    inline size_t get_rows() const { return n_rows; }

    inline size_t get_cols() const { return n_cols; }

    inline T* get_data() { return data; }
};

template <class T,size_t Rows,size_t Cols>
class Static_Matrix : public Matrix_Base<T,Static_Matrix<T,Rows,Cols>> 
{
private:

    T data[Rows * Cols];

public:

    Static_Matrix() {}

    inline size_t get_rows() const { return Rows; }

    inline size_t get_cols() const { return Cols; }

    inline T* get_data() { return data; }
};

template <class T,size_t Max_Rows,size_t Max_Cols>
class PDMatrix : public Matrix_Base<T,PDMatrix<T,Max_Rows,Max_Cols>> 
{
private:
    size_t n_rows,n_cols; // should be less than or equal Max_Rows and Max_Cols,respectively

    T data[Max_Rows * Max_Cols];
    
public:
    
    PDMatrix() : n_rows(0),n_cols(0) {}

    PDMatrix(const size_t n_rows,const size_t n_cols) : n_rows(n_rows),n_cols(n_cols) {}
};

int main() 
{
    Static_Matrix<double,4,4> sm;
    Dynamic_Matrix<double> dm(4,4);
    PDMatrix<double,16,16> pdm;
    // Want to do e.g.
    // pdm = sm + dm;
    // pdm = sm * dm;
    // etc..,for all configurations of Static_Matrix<T,Cols> and
    // PDMatrix<T,Max_Cols>

    return 0;
}

我该如何对这些二进制运算符进行基类或全局实现，例如所示的情况，以避免在每个派生类中有单独的实现？

注意：：由于该库应该在GPU上使用，因此我无法在此处使用Boost，标准功能等帮助我。