设计一个二维矩阵类，成员变量为double*类型，用来存储矩阵中的元素，写出赋值运算符重载(包括+=，-=，*=)，拷贝构造函数和构造函数，实现矩阵的转置操作，实现矩阵的逆求解，实现矩阵的行列式运算，矩阵的加减乘操作，利用（）运算符重载可以改变某个矩阵元素的值

好的，我来解答你的问题。

首先我们需要设计一个二维矩阵类，成员变量为double*类型，用来存储矩阵中的元素，如下所示：

class Matrix {
private:
    double* data; // 存储矩阵元素的指针
    int rows; // 矩阵的行数
    int cols; // 矩阵的列数
public:
    Matrix(int r, int c); // 构造函数
    Matrix(const Matrix& m); // 拷贝构造函数
    ~Matrix(); // 析构函数
    double& operator()(int i, int j); // 重载()运算符
    Matrix& operator=(const Matrix& m); // 重载=运算符
    Matrix& operator+=(const Matrix& m); // 重载+=运算符
    Matrix& operator-=(const Matrix& m); // 重载-=运算符
    Matrix& operator*=(double k); // 重载*=运算符
    Matrix operator~() const; // 矩阵的转置操作
    Matrix operator!() const; // 矩阵的逆求解
    double det() const; // 矩阵的行列式运算
    friend Matrix operator+(const Matrix& m1, const Matrix& m2); // 矩阵的加法运算
    friend Matrix operator-(const Matrix& m1, const Matrix& m2); // 矩阵的减法运算
    friend Matrix operator*(const Matrix& m1, const Matrix& m2); // 矩阵的乘法运算
};

其中，构造函数、拷贝构造函数和析构函数的实现如下：

Matrix::Matrix(int r, int c) {
    rows = r;
    cols = c;
    data = new double[rows * cols];
}

Matrix::Matrix(const Matrix& m) {
    rows = m.rows;
    cols = m.cols;
    data = new double[rows * cols];
    for (int i = 0; i < rows * cols; i++) {
        data[i] = m.data[i];
    }
}

Matrix::~Matrix() {
    delete[] data;
}

接下来，我们需要实现赋值运算符重载、+=、-=、*=运算符重载、转置操作、逆求解、行列式运算、加减乘运算和()运算符重载，具体实现如下：

double& Matrix::operator()(int i, int j) {
    return data[i * cols + j];
}

Matrix& Matrix::operator=(const Matrix& m) {
    if (this != &m) {
        delete[] data;
        rows = m.rows;
        cols = m.cols;
        data = new double[rows * cols];
        for (int i = 0; i < rows * cols; i++) {
            data[i] = m.data[i];
        }
    }
    return *this;
}

Matrix& Matrix::operator+=(const Matrix& m) {
    assert(rows == m.rows && cols == m.cols);
    for (int i = 0; i < rows * cols; i++) {
        data[i] += m.data[i];
    }
    return *this;
}

Matrix& Matrix::operator-=(const Matrix& m) {
    assert(rows == m.rows && cols == m.cols);
    for (int i = 0; i < rows * cols; i++) {
        data[i] -= m.data[i];
    }
    return *this;
}

Matrix& Matrix::operator*=(double k) {
    for (int i = 0; i < rows * cols; i++) {
        data[i] *= k;
    }
    return *this;
}

Matrix Matrix::operator~() const {
    Matrix res(cols, rows);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            res(j, i) = (*this)(i, j);
        }
    }
    return res;
}

Matrix Matrix::operator!() const {
    assert(rows == cols);
    Matrix res(rows, cols * 2);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            res(i, j) = (*this)(i, j);
        }
        res(i, i + cols) = 1;
    }
    for (int i = 0; i < rows; i++) {
        assert(res(i, i) != 0);
        for (int j = i + 1; j < rows; j++) {
            double k = res(j, i) / res(i, i);
            for (int l = i; l < cols * 2; l++) {
                res(j, l) -= k * res(i, l);
            }
        }
    }
    for (int i = rows - 1; i >= 0; i--) {
        for (int j = i - 1; j >= 0; j--) {
            double k = res(j, i) / res(i, i);
            for (int l = i; l < cols * 2; l++) {
                res(j, l) -= k * res(i, l);
            }
        }
    }
    Matrix ans(rows, cols);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            ans(i, j) = res(i, j + cols) / res(i, i);
        }
    }
    return ans;
}

double Matrix::det() const {
    assert(rows == cols);
    Matrix tmp(*this);
    double res = 1;
    for (int i = 0; i < rows; i++) {
        int p = i;
        for (int j = i + 1; j < rows; j++) {
            if (fabs(tmp(j, i)) > fabs(tmp(p, i))) {
                p = j;
            }
        }
        if (p != i) {
            for (int j = i; j < rows; j++) {
                swap(tmp(i, j), tmp(p, j));
            }
            res = -res;
        }
        res *= tmp(i, i);
        if (fabs(tmp(i, i)) < eps) {
            return 0;
        }
        for (int j = i + 1; j < rows; j++) {
            double k = tmp(j, i) / tmp(i, i);
            for (int l = i; l < rows; l++) {
                tmp(j, l) -= k * tmp(i, l);
            }
        }
    }
    return res;
}

Matrix operator+(const Matrix& m1, const Matrix& m2) {
    assert(m1.rows == m2.rows && m1.cols == m2.cols);
    Matrix res(m1.rows, m1.cols);
    for (int i = 0; i < m1.rows * m1.cols; i++) {
        res.data[i] = m1.data[i] + m2.data[i];
    }
    return res;
}

Matrix operator-(const Matrix& m1, const Matrix& m2) {
    assert(m1.rows == m2.rows && m1.cols == m2.cols);
    Matrix res(m1.rows, m1.cols);
    for (int i = 0; i < m1.rows * m1.cols; i++) {
        res.data[i] = m1.data[i] - m2.data[i];
    }
    return res;
}

Matrix operator*(const Matrix& m1, const Matrix& m2) {
    assert(m1.cols == m2.rows);
    Matrix res(m1.rows, m2.cols);
    for (int i = 0; i < res.rows; i++) {
        for (int j = 0; j < res.cols; j++) {
            for (int k = 0; k < m1.cols; k++) {
                res(i, j) += m1(i, k) * m2(k, j);
            }
        }
    }
    return res;
}

最后，我们需要实现()运算符重载，用来改变某个矩阵元素的值，如下所示：

double& Matrix::operator()(int i, int j) {
    return data[i * cols + j];
}

以上就是二维矩阵类的设计与实现，您可以根据需要进行修改和完善。