矩阵类模板（类模板）

题目描述

设计一个矩阵类模板Matrix，支持任意数据类型的数据。

要求至少包含2个成员函数：矩阵转置函数transport、以及打印输出函数print

编写main函数进行测试，调用类的成员函数完成转置和输出。

输入

第一行先输入t，表示有t个测试用例

从第二行开始输入每个测试用例的数据。

首先输入数据类型，I表示int，D表示double，C表示char，接着输入两个参数m和n，分别表示矩阵的行和列

接下来输入矩阵的元素，一共m行，每行n个数据

输出

输出转置后的矩阵 

输入样例1 

2\n
I 2 3\n
1 2 3\n
4 5 6\n
C 3 3\n
a b c\n
d e f\n
g h i

输出样例1

1 4\n
2 5\n
3 6\n
a d g\n
b e h\n
c f i

头文件

#include <iostream>
#include <string>

类模板实现

template <typename T>
class Matrix {
private:
    T** data;
    int rows;
    int cols;

public:
    Matrix(int m, int n) {
        rows = m;
        cols = n;
        data = new T * [m];//行
        for (int i = 0; i < m; i++) {
            data[i] = new T[n];//列
        }
    }
   Matrix& operator=(const Matrix& m)
    {
        rows = m.rows;
        cols = m.cols;
        data = new T * [rows];
        for (int i = 0; i < rows; i++) {
            data[i] = new T[cols];
        }
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                data[i][j] = m.data[i][j];
            }
        }
        return *this;
    }
    ~Matrix()
    {
        if (data == NULL)
        {
            return;
        }
        for (int i = 0; i < rows; i++)
        {
            delete[] data[i];
        }
        delete[] data;
        data = NULL;
    }
    void transport() {
        Matrix* temp=new Matrix(cols, rows);//n行 m列
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                (temp->data)[j][i] = data[i][j];
            }
        }
        for (int i = 0; i < rows; i++)//delete一维
        {
            delete[] data[i];
        }
        delete[] data;//delete二维
        *this = *temp;//自身改变，拷贝一份temp，传给*this
        delete temp;
    }

    void print() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols-1; j++) {
                cout << data[i][j] << " ";
                
            }
            cout << data[i][cols - 1] << endl;
            //cout << endl;
        }
    }

    T* operator[](int i) {
        return data[i];
    }
};

 main函数

int main() {
    int t;
    cin >> t;
    while (t--) {
        char type;
        int m, n;
        cin >> type >> m >> n;
        Matrix<char>* matrix_c;
        Matrix<int>* matrix_i;
        Matrix<double>* matrix_d;
        //声明了三个指针，分别指向Matrix类的三个不同实例，
        //这三个实例分别使用了不同的模板参数类型
        if (type == 'C') {
            matrix_c = new Matrix<char>(m, n);//初始化
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    cin >> (*matrix_c)[i][j];
                }
            }
            matrix_c->transport();
            matrix_c->print();
            delete matrix_c;
        }
        else if (type == 'I') {
            matrix_i = new Matrix<int>(m, n);
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    cin >> (*matrix_i)[i][j];
                }
            }
            matrix_i->transport();
            matrix_i->print();
            delete matrix_i;
        }
        else if (type == 'D') {
            matrix_d = new Matrix<double>(m, n);
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    cin >> (*matrix_d)[i][j];
                }
            }
            matrix_d->transport();
            matrix_d->print();
            delete matrix_d;
        }
    }
    return 0;
}

细剖transport函数

void transport() {
        Matrix* temp=new Matrix(cols, rows);//n行 m列
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                (temp->data)[j][i] = data[i][j];
            }
        }
        for (int i = 0; i < rows; i++)//delete一维
        {
            delete[] data[i];
        }
        delete[] data;//delete二维
        *this = *temp;//自身改变，拷贝一份temp，传给*this
        delete temp;
    }

首先new了一个对象指针* temp，两个for循环实现矩阵转置。

for (int i = 0; i < rows; i++)//delete一维
        {
            delete[] data[i];
        }

这里delete了初始化Matrix对象时new的列，一维动态指针。

delete[] data;//delete二维

这里把二维动态指针删掉了。

*this = *temp;//自身改变，拷贝一份temp，传给*this

重载了运算符"=",这里会进行拷贝构造(深拷贝)，新开辟了一份内存给*this，这里*this还是指向一开始的类，把temp里的东西都赋给*this。

delete temp;

这里会调用析构函数，delete掉上面new出来的* temp。

至此，函数运行完毕，整个过程出现三块内存，最开始的内存有输入的矩阵，* temp的内存有转置后的矩阵，最后的内存(只剩下这块)有从* temp拷贝过去的矩阵，到时调用print()方法就能使用到类里的数据。