写一个矩阵类CMatrix,基本要求如下: 支持任意大小的矩阵:行数和列数可以动态设置(不用修改代码) 实现拷贝构造函数 重载操作符*，实现矩阵相乘 重载操作符++和一，分别实现矩阵元素同时+1和-1 重载操作符=,实现矩阵的赋值 在main函数， 中对以上功能进行调用

好的，以下是 C++ 实现的矩阵类 CMatrix，包括所述的基本要求。请注意，为了简化代码，该矩阵类仅支持 int 类型的矩阵。

#include <iostream>

using namespace std;

class CMatrix {
public:
    // 构造函数，初始化矩阵大小
    CMatrix(int row = 0, int col = 0): m_row(row), m_col(col) {
        if (row > 0 && col > 0) {
            m_data = new int*[row];
            for (int i = 0; i < row; i++) {
                m_data[i] = new int[col];
                for (int j = 0; j < col; j++) {
                    m_data[i][j] = 0;
                }
            }
        } else {
            m_data = nullptr;
        }
    }

    // 拷贝构造函数
    CMatrix(const CMatrix& rhs): CMatrix(rhs.m_row, rhs.m_col) {
        for (int i = 0; i < m_row; i++) {
            for (int j = 0; j < m_col; j++) {
                m_data[i][j] = rhs.m_data[i][j];
            }
        }
    }

    // 重载操作符*
    CMatrix operator*(const CMatrix& rhs) const {
        if (m_col != rhs.m_row) {
            // 矩阵无法相乘，返回空矩阵
            return CMatrix();
        }

        CMatrix result(m_row, rhs.m_col);
        for (int i = 0; i < m_row; i++) {
            for (int j = 0; j < rhs.m_col; j++) {
                for (int k = 0; k < m_col; k++) {
                    result.m_data[i][j] += m_data[i][k] * rhs.m_data[k][j];
                }
            }
        }
        return result;
    }

    // 重载操作符++，实现矩阵元素同时+1
    CMatrix operator++() {
        for (int i = 0; i < m_row; i++) {
            for (int j = 0; j < m_col; j++) {
                m_data[i][j]++;
            }
        }
        return *this;
    }

    // 重载操作符--，实现矩阵元素同时-1
    CMatrix operator--() {
        for (int i = 0; i < m_row; i++) {
            for (int j = 0; j < m_col; j++) {
                m_data[i][j]--;
            }
        }
        return *this;
    }

    // 重载操作符=，实现矩阵的赋值
    CMatrix& operator=(const CMatrix& rhs) {
        if (&rhs == this) {
            return *this;
        }

        // 释放原有内存
        if (m_data != nullptr) {
            for (int i = 0; i < m_row; i++) {
                delete[] m_data[i];
            }
            delete[] m_data;
        }

        m_row = rhs.m_row;
        m_col = rhs.m_col;
        if (m_row > 0 && m_col > 0) {
            m_data = new int*[m_row];
            for (int i = 0; i < m_row; i++) {
                m_data[i] = new int[m_col];
                for (int j = 0; j < m_col; j++) {
                    m_data[i][j] = rhs.m_data[i][j];
                }
            }
        } else {
            m_data = nullptr;
        }
        return *this;
    }

    // 析构函数
    ~CMatrix() {
        if (m_data != nullptr) {
            for (int i = 0; i < m_row; i++) {
                delete[] m_data[i];
            }
            delete[] m_data;
        }
    }

    // 打印矩阵
    void print() const {
        for (int i = 0; i < m_row; i++) {
            for (int j = 0; j < m_col; j++) {
                cout << m_data[i][j] << " ";
            }
            cout << endl;
        }
    }

private:
    int m_row;
    int m_col;
    int** m_data;
};

int main() {
    // 初始化矩阵
    CMatrix mat1(2, 3);
    CMatrix mat2(3, 2);

    // 赋值
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            mat1(i, j) = (i + 1) * (j + 1);
        }
    }

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            mat2(i, j) = i + j;
        }
    }

    // 打印矩阵
    cout << "mat1:" << endl;
    mat1.print();

    cout << "mat2:" << endl;
    mat2.print();

    // 矩阵相乘
    cout << "mat1 * mat2:" << endl;
    CMatrix mat3 = mat1 * mat2;
    mat3.print();

    // 矩阵元素同时+1
    cout << "++mat1:" << endl;
    ++mat1;
    mat1.print();

    // 矩阵元素同时-1
    cout << "--mat2:" << endl;
    --mat2;
    mat2.print();

    // 矩阵赋值
    cout << "mat1 = mat2:" << endl;
    mat1 = mat2;
    mat1.print();

    return 0;
}

在以上代码中，CMatrix 类中的 `operator*` 实现了矩阵相乘，`operator++` 和 `operator--` 实现了矩阵元素同时加减 1，`operator=` 实现了矩阵的赋值。在 main 函数中，我们对这些功能进行了调用，并输出了结果。