定义一个矩阵类模板templatesclassT>classMatrix 数据成员（访问权限定义为protected): 指向存放矩阵内容的二维指针(T**content 矩阵的行和列(size_trow;size_tcolumn) 成员西数（访问权限定义为public)： •带默认参数的构造西数：根据参数规定的行和列的值初始化矩阵空间 Matrix(size_t_row=5,size_t_column=5); •拷贝构造西数：初始化矩阵 Matrix(constMatrix-T>&matrix); •析构两数：释放堆空间 ~Matrix ); •初始化矩阵内容voidinit(T**mat); •获取矩阵的行（定义为const成员西数）size_tgetRow0const; •获取矩阵的列（定义为const成员西数）size_IgetColumnOconst; •打印矩阵内容（定义为const成员两数）voidprintOconst; •重载赋值运算符=（只能作为类成员函数重载） Matrix<T>&operator=(constMatrix-T>&matrix); •重载加法运算符＋，实现两个矩阵相加 Matrix<T>operator+(constMatrix-T>&matrix); •重载函数调用运算符()，实现获取矩阵中某个指定位置的元素（只能作 为类成员雨数重载） T& operator0(size_t rindex, size_t cindex);

好的，以下是矩阵类模板的定义：

template<class T>
class Matrix {
protected:
    T** content;    // 存放矩阵内容的二维指针
    size_t row;     // 矩阵的行数
    size_t column;  // 矩阵的列数
public:
    // 带默认参数的构造函数，根据参数规定的行列数值初始化矩阵空间
    Matrix(size_t _row = 5, size_t _column = 5);

    // 拷贝构造函数，初始化矩阵
    Matrix(const Matrix<T>& matrix);

    // 析构函数，释放堆空间
    ~Matrix();

    // 初始化矩阵内容
    void init(T** mat);

    // 获取矩阵的行数
    size_t getRow() const;

    // 获取矩阵的列数
    size_t getColumn() const;

    // 打印矩阵内容
    void print() const;

    // 重载赋值运算符
    Matrix<T>& operator=(const Matrix<T>& matrix);

    // 重载加法运算符，实现两个矩阵相加
    Matrix<T> operator+(const Matrix<T>& matrix);

    // 重载函数调用运算符，实现获取矩阵中某个指定位置的元素
    T& operator()(size_t rindex, size_t cindex);
};

// 带默认参数的构造函数的实现
template<class T>
Matrix<T>::Matrix(size_t _row, size_t _column) {
    row = _row;
    column = _column;
    content = new T*[row];
    for (size_t i = 0; i < row; i++) {
        content[i] = new T[column];
    }
}

// 拷贝构造函数的实现
template<class T>
Matrix<T>::Matrix(const Matrix<T>& matrix) {
    row = matrix.getRow();
    column = matrix.getColumn();
    content = new T*[row];
    for (size_t i = 0; i < row; i++) {
        content[i] = new T[column];
        for (size_t j = 0; j < column; j++) {
            content[i][j] = matrix.content[i][j];
        }
    }
}

// 析构函数的实现
template<class T>
Matrix<T>::~Matrix() {
    for (size_t i = 0; i < row; i++) {
        delete[] content[i];
    }
    delete[] content;
}

// 初始化矩阵内容的实现
template<class T>
void Matrix<T>::init(T** mat) {
    for (size_t i = 0; i < row; i++) {
        for (size_t j = 0; j < column; j++) {
            content[i][j] = mat[i][j];
        }
    }
}

// 获取矩阵的行数的实现
template<class T>
size_t Matrix<T>::getRow() const {
    return row;
}

// 获取矩阵的列数的实现
template<class T>
size_t Matrix<T>::getColumn() const {
    return column;
}

// 打印矩阵内容的实现
template<class T>
void Matrix<T>::print() const {
    for (size_t i = 0; i < row; i++) {
        for (size_t j = 0; j < column; j++) {
            std::cout << content[i][j] << "\t";
        }
        std::cout << std::endl;
    }
}

// 重载赋值运算符的实现
template<class T>
Matrix<T>& Matrix<T>::operator=(const Matrix<T>& matrix) {
    if (this != &matrix) {
        for (size_t i = 0; i < row; i++) {
            delete[] content[i];
        }
        delete[] content;
        row = matrix.getRow();
        column = matrix.getColumn();
        content = new T*[row];
        for (size_t i = 0; i < row; i++) {
            content[i] = new T[column];
            for (size_t j = 0; j < column; j++) {
                content[i][j] = matrix.content[i][j];
            }
        }
    }
    return *this;
}

// 重载加法运算符的实现
template<class T>
Matrix<T> Matrix<T>::operator+(const Matrix<T>& matrix) {
    Matrix<T> result(row, column);
    if (row == matrix.getRow() && column == matrix.getColumn()) {
        for (size_t i = 0; i < row; i++) {
            for (size_t j = 0; j < column; j++) {
                result.content[i][j] = content[i][j] + matrix.content[i][j];
            }
        }
    }
    return result;
}

// 重载函数调用运算符的实现
template<class T>
T& Matrix<T>::operator()(size_t rindex, size_t cindex) {
    return content[rindex][cindex];
}