动态数组类，写一个矩阵类 - 实现类的构造、析构、拷贝、赋值等基本操作 - 实现矩阵的按元素加减乘除运算，以及矩阵乘法、转置、求逆等运算

好的，下面是一个基于动态数组的矩阵类的实现，包括类的构造、析构、拷贝、赋值等基本操作，以及矩阵的按元素加减乘除运算，矩阵的乘法、转置和求逆等运算：

#include <iostream>
#include <vector>
using namespace std;

class Matrix {
private:
    int row;
    int col;
    vector<vector<double>> data;

public:
    // 构造函数
    Matrix(int r, int c, double val = 0) {
        row = r;
        col = c;
        data.resize(row, vector<double>(col, val));
    }

    // 拷贝构造函数
    Matrix(const Matrix &other) {
        row = other.row;
        col = other.col;
        data = other.data;
    }

    // 析构函数
    ~Matrix() {}

    // 赋值运算符
    Matrix &operator=(const Matrix &other) {
        if (this != &other) {
            row = other.row;
            col = other.col;
            data = other.data;
        }
        return *this;
    }

    // 矩阵按元素加法
    Matrix operator+(const Matrix &other) const {
        if (row != other.row || col != other.col) {
            throw "矩阵加法维度不匹配!";
        }
        Matrix result(row, col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                result.data[i][j] = data[i][j] + other.data[i][j];
            }
        }
        return result;
    }

    // 矩阵按元素减法
    Matrix operator-(const Matrix &other) const {
        if (row != other.row || col != other.col) {
            throw "矩阵减法维度不匹配!";
        }
        Matrix result(row, col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                result.data[i][j] = data[i][j] - other.data[i][j];
            }
        }
        return result;
    }

    // 矩阵按元素乘法
    Matrix operator*(const Matrix &other) const {
        if (row != other.row || col != other.col) {
            throw "矩阵乘法维度不匹配!";
        }
        Matrix result(row, col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                result.data[i][j] = data[i][j] * other.data[i][j];
            }
        }
        return result;
    }

    // 矩阵按元素除法
    Matrix operator/(const Matrix &other) const {
        if (row != other.row || col != other.col) {
            throw "矩阵除法维度不匹配!";
        }
        Matrix result(row, col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (other.data[i][j] == 0) {
                    throw "矩阵除法除数不能为0!";
                }
                result.data[i][j] = data[i][j] / other.data[i][j];
            }
        }
        return result;
    }

    // 矩阵乘法
    Matrix operator*(const Matrix &other) const {
        if (col != other.row) {
            throw "矩阵乘法维度不匹配!";
        }
        Matrix result(row, other.col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < other.col; j++) {
                for (int k = 0; k < col; k++) {
                    result.data[i][j] += data[i][k] * other.data[k][j];
                }
            }
        }
        return result;
    }

    // 矩阵转置
    Matrix transpose() const {
        Matrix result(col, row);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                result.data[j][i] = data[i][j];
            }
        }
        return result;
    }

    // 矩阵求逆
    Matrix inverse() const {
        if (row != col) {
            throw "非方阵不可求逆!";
        }
        int n = row;
        Matrix A(*this);
        Matrix B(n, n);
        B.eye();
        for (int k = 0; k < n; k++) {
            double max = abs(A.data[k][k]);
            int index = k;
            // 找到最大元素所在的行
            for (int i = k + 1; i < n; i++) {
                if (abs(A.data[i][k]) > max) {
                    max = abs(A.data[i][k]);
                    index = i;
                }
            }
            // 如果最大元素为0，则该矩阵不可逆
            if (max == 0) {
                throw "该矩阵不可逆!";
            }
            // 交换第k行和第index行
            if (index != k) {
                for (int j = 0; j < n; j++) {
                    swap(A.data[k][j], A.data[index][j]);
                    swap(B.data[k][j], B.data[index][j]);
                }
            }
            // 使A[k][k]为1
            double d = A.data[k][k];
            for (int j = 0; j < n; j++) {
                A.data[k][j] /= d;
                B.data[k][j] /= d;
            }
            // 使A[k][j](j!=k)为0
            for (int i = k + 1; i < n; i++) {
                double d = A.data[i][k];
                for (int j = 0; j < n; j++) {
                    A.data[i][j] -= d * A.data[k][j];
                    B.data[i][j] -= d * B.data[k][j];
                }
            }
        }
        // 使A[j][k](j!=k)为0
        for (int k = n - 1; k > 0; k--) {
            for (int i = k - 1; i >= 0; i--) {
                double d = A.data[i][k];
                for (int j = 0; j < n; j++) {
                    A.data[i][j] -= d * A.data[k][j];
                    B.data[i][j] -= d * B.data[k][j];
                }
            }
        }
        return B;
    }

    // 单位矩阵
    void eye() {
        if (row != col) {
            throw "非方阵不可转化为单位矩阵!";
        }
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                data[i][j] = (i == j) ? 1 : 0;
            }
        }
    }

    // 输出矩阵元素
    void print() const {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                cout << data[i][j] << "\t";
            }
            cout << endl;
        }
    }
};

在这个矩阵类中，我们使用了动态二维数组来存储矩阵的数据。在构造函数中，我们使用了resize()函数来动态分配内存。在拷贝构造函数和赋值运算符中，我们直接复制了矩阵的行列数和数据，而不是使用浅拷贝。

在矩阵的按元素加减乘除运算中，我们首先检查了两个矩阵的维度是否匹配，然后按照对应元素相加减乘除的方式计算结果，并返回一个新的矩阵对象。

在矩阵的乘法运算中，我们首先检查了两个矩阵的维度是否匹配，然后按照矩阵乘法的定义计算结果，并返回一个新的矩阵对象。

在矩阵的转置和求逆运算中，我们使用了一些常见的线性代数算法来实现。需要注意的是，在求逆运算中，我们使用了高斯-约旦消元法来求解矩阵的逆矩阵，该算法的时间复杂度为O(n^3)。

最后，我们还实现了一个输出矩阵元素的函数print()，用于调试和测试。