定义一个矩阵类模板 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); • 打印矩阵内容（定义为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);

下面是矩阵类模板的实现：

#include <iostream>

using namespace std;

template <class T>
class Matrix {
protected:
    T** content;
    size_t row;
    size_t column;

public:
    Matrix(size_t _row = 5, size_t _column = 5) : row(_row), column(_column) {
        content = new T*[row];
        for (size_t i = 0; i < row; i++) {
            content[i] = new T[column];
        }
    }

    Matrix(const Matrix<T>& matrix) : row(matrix.row), column(matrix.column) {
        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];
            }
        }
    }

    ~Matrix() {
        for (size_t i = 0; i < row; i++) {
            delete[] content[i];
        }
        delete[] content;
    }

    void 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];
            }
        }
    }

    void print() const {
        for (size_t i = 0; i < row; i++) {
            for (size_t j = 0; j < column; j++) {
                cout << content[i][j] << " ";
            }
            cout << endl;
        }
    }

    Matrix<T>& operator=(const Matrix<T>& matrix) {
        if (this == &matrix) {
            return *this;
        }
        for (size_t i = 0; i < row; i++) {
            delete[] content[i];
        }
        delete[] content;

        row = matrix.row;
        column = matrix.column;
        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;
    }

    Matrix<T> operator+(const Matrix<T>& matrix) {
        if (row != matrix.row || column != matrix.column) {
            throw "两个矩阵的行和列不相同，不能相加！";
        }
        Matrix<T> result(row, column);
        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;
    }

    T& operator()(size_t rindex, size_t cindex) {
        if (rindex >= row || cindex >= column) {
            throw "矩阵下标越界！";
        }
        return content[rindex][cindex];
    }
};

这里需要注意的是，为了方便起见，我们只实现了一个加法运算符，而没有实现减法、乘法等运算符。如果需要实现这些运算符，可以仿照加法运算符的实现方式进行编写。另外，函数调用运算符可以用来获取矩阵中某个指定位置的元素，因此需要返回一个 T 类型的引用，以便可以修改该元素的值。