实现泛型矩阵的基本运算。 首先，定义一个矩阵类作为基类，类中需要包含维度值 m （行）和 n （列）。并在构造函数中动态申请内存空间，实例化 m * n 的 int 型二维数组，重载＋和﹣作为矩阵加减法运算符，包含按照 m 行 n 列打印出矩阵的 show 方法，析构函数包含动态释放内存空间。 接下来，定义一个4*4方阵类作为矩阵类的派生类，包含成员方法求行列式的值，包含成员方法左乘矩阵打印出结果，注意规格检查。 最后，定义一个主函数，随机生成5*6矩阵 A ,5*6矩阵 B ,5*6矩阵 C ，计算 a + b , a - c ；随机生成4*4方阵 D ,4*4方阵 E ，计算 D * E ，计算 D 和 E 的行列式，判断 D * A 的可计算性。

好的，我会为您解答这个问题。

以下是实现泛型矩阵的基本运算的代码：

#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

template<typename T>
class Matrix {
private:
    int m, n;
    T **data;
public:
    Matrix(int m=0, int n=0):m(m), n(n) {
        data = new T*[m];
        for(int i=0; i<m; i++) {
            data[i] = new T[n];
            for(int j=0; j<n; j++) {
                data[i][j] = 0;
            }
        }
    }
    Matrix(const Matrix &matrix):m(matrix.m), n(matrix.n) {
        data = new T*[m];
        for(int i=0; i<m; i++) {
            data[i] = new T[n];
            for(int j=0; j<n; j++) {
                data[i][j] = matrix.data[i][j];
            }
        }
    }
    Matrix operator+(const Matrix &matrix) {
        Matrix result(m, n);
        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                result.data[i][j] = data[i][j] + matrix.data[i][j];
            }
        }
        return result;
    }
    Matrix operator-(const Matrix &matrix) {
        Matrix result(m, n);
        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                result.data[i][j] = data[i][j] - matrix.data[i][j];
            }
        }
        return result;
    }
    void show() {
        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                cout << data[i][j] << " ";
            }
            cout << endl;
        }
    }
    ~Matrix() {
        for(int i=0; i<m; i++) {
            delete[] data[i];
        }
        delete[] data;
    }
};

class SquareMatrix: public Matrix<int> {
public:
    SquareMatrix(int n=0):Matrix<int>(n, n) {}
    SquareMatrix(const SquareMatrix &matrix):Matrix<int>(matrix) {}
    int determinant() {
        if(m != n) {
            cout << "该矩阵不是方阵，无法求行列式" << endl;
            return 0;
        }
        int det = 0;
        if(n == 1) {
            det = data[0][0];
        } else {
            for(int i=0; i<n; i++) {
                SquareMatrix submatrix(n-1);
                for(int j=1; j<n; j++) {
                    for(int k=0; k<n; k++) {
                        if(k != i) {
                            submatrix.data[j-1][k<k?k:(k-1)] = data[j][k];
                        }
                    }
                }
                det += (i%2==0?1:-1) * data[0][i] * submatrix.determinant();
            }
        }
        return det;
    }
    void leftMultiply(const Matrix<int> &matrix) {
        if(n != matrix.m) {
            cout << "矩阵尺寸不匹配，无法左乘" << endl;
            return;
        }
        Matrix<int> result(m, matrix.n);
        for(int i=0; i<m; i++) {
            for(int j=0; j<matrix.n; j++) {
                for(int k=0; k<n; k++) {
                    result.data[i][j] += data[i][k] * matrix.data[k][j];
                }
            }
        }
        result.show();
    }
};

int main() {
    srand(time(NULL));
    Matrix<int> A(5, 6), B(5, 6), C(5, 6);
    for(int i=0; i<5; i++) {
        for(int j=0; j<6; j++) {
            A[i][j] = rand() % 10;
            B[i][j] = rand() % 10;
            C[i][j] = rand() % 10;
        }
    }
    cout << "矩阵A:" << endl;
    A.show();
    cout << "矩阵B:" << endl;
    B.show();
    cout << "矩阵C:" << endl;
    C.show();
    cout << "A + B:" << endl;
    (A+B).show();
    cout << "A - C:" << endl;
    (A-C).show();
    SquareMatrix D(4), E(4);
    for(int i=0; i<4; i++) {
        for(int j=0; j<4; j++) {
            D[i][j] = rand() % 10;
            E[i][j] = rand() % 10;
        }
    }
    cout << "方阵D:" << endl;
    D.show();
    cout << "方阵E:" << endl;
    E.show();
    cout << "D * E:" << endl;
    (D*E).show();
    cout << "D 的行列式:" << endl;
    cout << D.determinant() << endl;
    cout << "E 的行列式:" << endl;
    cout << E.determinant() << endl;
    cout << "D * A:" << endl;
    D.leftMultiply(A);
    return 0;
}

以上代码实现了泛型矩阵的基本运算，包括矩阵的加减法、按照 m 行 n 列打印出矩阵的 show 方法、析构函数的内存释放；并定义了一个4*4方阵类作为矩阵类的派生类，包含成员方法求行列式的值、成员方法左乘矩阵打印出结果，并进行了相应的规格检查。

在主函数中，随机生成5*6矩阵 A ,5*6矩阵 B ,5*6矩阵 C ，计算 a + b , a - c ；随机生成4*4方阵 D ,4*4方阵 E ，计算 D * E ，计算 D 和 E 的行列式，判断 D * A 的可计算性。