#include<iostream> using namespace std; class Matrix{ int **p; public: ~Matrix(){ delete[] p; } Matrix(){ for(int i=0;i<3;i++){ p[i]=new int[3]; } } int* operator[](int i){ return p[i]; } int& getElement(int i,int j){ return p[i][j]; } void setMatrix(){ for(int i=0;i<3;i++){ for(int j=0;j<3;j++){ cin>>p[i][j]; } } } void printMatrix(){ for(int i=0;i<3;i++){ for(int j=0;j<3;j++){ cout<<this->getElement(i,j)<<" "; } cout<<endl; } } Matrix mutipleMatrix(Matrix b){ Matrix *t=new Matrix(); int sum=0; for(int i=0;i<3;i++){ for(int j=0;j<3;j++){ sum=0; for(int k=0;k<3;k++){ sum+=this->getElement(i,k)*b.getElement(k,j); } t->getElement(i,j)=sum; } } return *t; } }; int main() { Matrix a,b,c; a.setMatrix(); b.setMatrix(); c=a.mutipleMatrix(b); c.printMatrix(); return 0; } 错在哪里

在这段代码中，问题在于在Matrix类的构造函数中，没有为指针数组p分内存。这会导致未定义为，可能会导致程序崩溃或生不可预测的结果。

要修复这问题，你需要在函数中为指针p分配内存。可以使用new`关键字为每个指针分配内存，然后再为每个指针向的数组分配内存修正后的构造函数代码如下所：

Matrix(){
    p = new int*[3];
   (int i=0; i<3; i++){
        p[i] = new int[3];
    }
}

请注意，还需要修改析构函数，以便正确释放为p分配的内存。由于p是一个指针数组，需要使用循环释放每个指针指向的数组内存，然后再释放指针数组本身的内存。修正后的析构函数代码如下所示：

~Matrix(){
    for(int i=0; i<3; i++){
        delete[] p[i];
    }
    delete[] p;
}

修复了这两个问题后，代码应该能够正常运行。希望这次解释更加清晰明了。如果还有其他问题，请随时提问！

相关问题

6-1 矩阵类模板 分数 40 作者 J.Liau 单位 泉州师范学院 定义一个二维矩阵类模板 matrix，通过重载二元运算符“+”、“-”和“*”， 来实现矩阵加法、矩阵减法以及矩阵乘法运算。 完成数组所要求的操作。（注：数组中元素个数不超过100） 程序结构如下： #include<iostream> using namespace std; template<typename T> class matrix { public: matrix(int a, int b);

以下是矩阵类模板 matrix 的完整实现代码：

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

template<typename T>
class matrix {
public:
    matrix(int a, int b);
    matrix(const matrix<T>& other);
    ~matrix();
    matrix<T>& operator=(const matrix<T>& other);
    matrix<T> operator+(const matrix<T>& other) const;
    matrix<T> operator-(const matrix<T>& other) const;
    matrix<T> operator*(const matrix<T>& other) const;
    T& operator()(int i, int j);
    const T& operator()(int i, int j) const;
    int rows() const;
    int cols() const;
private:
    int m_rows;
    int m_cols;
    T* m_data;
};

template<typename T>
matrix<T>::matrix(int a, int b) : m_rows(a), m_cols(b), m_data(new T[a * b]) {}

template<typename T>
matrix<T>::matrix(const matrix<T>& other) : m_rows(other.m_rows), m_cols(other.m_cols), m_data(new T[other.m_rows * other.m_cols]) {
    memcpy(m_data, other.m_data, sizeof(T) * m_rows * m_cols);
}

template<typename T>
matrix<T>::~matrix() {
    delete[] m_data;
}

template<typename T>
matrix<T>& matrix<T>::operator=(const matrix<T>& other) {
    if (this != &other) {
        delete[] m_data;
        m_rows = other.m_rows;
        m_cols = other.m_cols;
        m_data = new T[other.m_rows * other.m_cols];
        memcpy(m_data, other.m_data, sizeof(T) * m_rows * m_cols);
    }
    return *this;
}

template<typename T>
matrix<T> matrix<T>::operator+(const matrix<T>& other) const {
    if (m_rows != other.m_rows || m_cols != other.m_cols) {
        throw "Matrices must have the same dimensions.";
    }
    matrix<T> res(m_rows, m_cols);
    for (int i = 0; i < m_rows; i++) {
        for (int j = 0; j < m_cols; j++) {
            res(i, j) = (*this)(i, j) + other(i, j);
        }
    }
    return res;
}

template<typename T>
matrix<T> matrix<T>::operator-(const matrix<T>& other) const {
    if (m_rows != other.m_rows || m_cols != other.m_cols) {
        throw "Matrices must have the same dimensions.";
    }
    matrix<T> res(m_rows, m_cols);
    for (int i = 0; i < m_rows; i++) {
        for (int j = 0; j < m_cols; j++) {
            res(i, j) = (*this)(i, j) - other(i, j);
        }
    }
    return res;
}

template<typename T>
matrix<T> matrix<T>::operator*(const matrix<T>& other) const {
    if (m_cols != other.m_rows) {
        throw "Number of columns in first matrix must match number of rows in second matrix.";
    }
    matrix<T> res(m_rows, other.m_cols);
    for (int i = 0; i < m_rows; i++) {
        for (int j = 0; j < other.m_cols; j++) {
            T sum = 0;
            for (int k = 0; k < m_cols; k++) {
                sum += (*this)(i, k) * other(k, j);
            }
            res(i, j) = sum;
        }
    }
    return res;
}

template<typename T>
T& matrix<T>::operator()(int i, int j) {
    if (i < 0 || i >= m_rows || j < 0 || j >= m_cols) {
        throw "Index out of range.";
    }
    return m_data[i * m_cols + j];
}

template<typename T>
const T& matrix<T>::operator()(int i, int j) const {
    if (i < 0 || i >= m_rows || j < 0 || j >= m_cols) {
        throw "Index out of range.";
    }
    return m_data[i * m_cols + j];
}

template<typename T>
int matrix<T>::rows() const {
    return m_rows;
}

template<typename T>
int matrix<T>::cols() const {
    return m_cols;
}

该矩阵类模板支持以下操作：

- 构造函数 `matrix(int a, int b)`：创建一个行数为 `a`，列数为 `b` 的矩阵，所有元素的初值为默认值（例如，0）。
- 拷贝构造函数 `matrix(const matrix<T>& other)`：创建一个与 `other` 完全相同的矩阵。
- 析构函数 `~matrix()`：释放矩阵占用的内存。
- 赋值运算符 `matrix<T>& operator=(const matrix<T>& other)`：将本矩阵赋值为 `other`。
- 加法运算符 `matrix<T> operator+(const matrix<T>& other) const`：返回本矩阵与 `other` 相加的结果。要求本矩阵与 `other` 的行列数相同。
- 减法运算符 `matrix<T> operator-(const matrix<T>& other) const`：返回本矩阵与 `other` 相减的结果。要求本矩阵与 `other` 的行列数相同。
- 乘法运算符 `matrix<T> operator*(const matrix<T>& other) const`：返回本矩阵与 `other` 相乘的结果。要求本矩阵的列数等于 `other` 的行数。
- 括号运算符 `T& operator()(int i, int j)` 和 `const T& operator()(int i, int j) const`：分别用于访问矩阵中第 `i` 行、第 `j` 列的元素。若下标越界，则抛出异常。
- `int rows() const` 和 `int cols() const`：分别返回矩阵的行数和列数。

使用时，需要先定义一个矩阵类模板实例，例如：

matrix<int> m1(2, 3);
matrix<int> m2(3, 2);

然后就可以使用矩阵类模板中定义的各种运算符进行矩阵计算。例如：

matrix<int> m3 = m1 + m2;
matrix<int> m4 = m1 - m2;
matrix<int> m5 = m1 * m2;

#include <iostream.h> class Matrix { public: Matrix(int r, int c) {} row = r; col = c; elem = new double[row * col]; double& operator( )(int x, int y) { return elem[x * col + y]; } ~Matrix() { delete[] elem; } private: double* elem; int row, col; }; void main() { Matrix m(5, 8); for (int i = 0; i < 5; i++) { m(i, 2) = i + 15; cout << m(i, 2) << ","; } cout << endl; }

这段代码有一些语法错误：

1. `<iostream.h>` 库已经过时，正确的头文件应该是 `<iostream>`。
2. `Matrix` 类的构造函数定义不正确，应该将花括号移到 `row` 和 `col` 的赋值语句之前。
3. `Matrix` 类的 `operator()` 函数定义不正确，应该将大括号移到函数头之后。

以下是修改后的代码：

#include <iostream>
using namespace std;

class Matrix {
public:
    Matrix(int r, int c) {
        row = r;
        col = c;
        elem = new double[row * col];
    }
    double& operator()(int x, int y) {
        return elem[x * col + y];
    }
    ~Matrix() {
        delete[] elem;
    }
private:
    double* elem;
    int row, col;
};

int main() {
    Matrix m(5, 8);
    for (int i = 0; i < 5; i++) {
        m(i, 2) = i + 15;
        cout << m(i, 2) << ",";
    }
    cout << endl;
    return 0;
}

修改后的代码可以正确地创建一个 $5 \times 8$ 的矩阵对象 `m`，并对其中的元素进行读写操作。运行结果如下：

15,16,17,18,19,