如何修复矩阵管理函数？setze_element函数实现求助

核心问题梳理 #

你当前的代码存在几个关键问题：

• Matrix类缺少存储矩阵数据的私有成员变量，也没有记录行列数的变量
• setze_element函数逻辑错误：用嵌套循环批量赋值，且未做合法的索引范围检查
• 缺少zeilen()和spalten()成员函数，CPP文件中的调用会直接报错
• 未正确处理内存的分配与释放，存在内存泄漏风险

具体实现步骤 #

1. 添加私有成员变量 #

在Matrix类的私有区域添加以下变量，用于存储矩阵数据和行列信息：

private:
    int rows;    // 行数
    int cols;    // 列数
    double** data; // 二维指针存储矩阵元素

2. 修正setze_element函数逻辑 #

该函数的作用是设置单个指定位置的元素值，而非批量赋值，正确实现如下：

int setze_element(int zeile, int spalte, double wert)
{
    // 检查索引是否在合法范围内
    if (zeile >= 0 && zeile < rows && spalte >=0 && spalte < cols)
    {
        data[zeile][spalte] = wert;
        return 1; // 返回1表示设置成功
    }
    else
    {
        cout << "Zeile und Spalte liegt ausserhalb des gültigen Bereichs!" << endl;
        return 0; // 返回0表示失败，将错误处理交给调用方，不要直接exit
    }
}

3. 补充必要的成员函数与内存管理 #

• 添加获取行列数的成员函数：

public:
    int zeilen() const { return rows; }
    int spalten() const { return cols; }

• 在带参数的构造函数中分配内存：

Matrix::Matrix(int zeilen, int spalten) : rows(zeilen), cols(spalten)
{
    // 分配行指针数组
    data = new double*[rows];
    // 为每一行分配列数据内存并初始化为0
    for (int i = 0; i < rows; i++)
    {
        data[i] = new double[cols]();
    }
}

• 在析构函数中释放内存：

Matrix::~Matrix()
{
    if (data != nullptr)
    {
        // 先释放每一行的列数据
        for (int i = 0; i < rows; i++)
        {
            delete[] data[i];
        }
        // 再释放行指针数组
        delete[] data;
    }
}

• 补充拷贝构造函数（避免浅拷贝问题）：

Matrix::Matrix(const Matrix& m) : rows(m.rows), cols(m.cols)
{
    data = new double*[rows];
    for (int i = 0; i < rows; i++)
    {
        data[i] = new double[cols];
        // 逐元素复制
        for (int j = 0; j < cols; j++)
        {
            data[i][j] = m.data[i][j];
        }
    }
}

4. 补充赋值运算符与输出运算符 #

赋值运算符需要处理自赋值和内存释放，输出运算符用于main函数中的矩阵打印：

Matrix Matrix::operator=(const Matrix& m)
{
    if (this == &m) return *this; // 防止自赋值

    // 释放当前对象的内存
    for (int i = 0; i < rows; i++)
    {
        delete[] data[i];
    }
    delete[] data;

    // 分配新内存并复制数据
    rows = m.rows;
    cols = m.cols;
    data = new double*[rows];
    for (int i = 0; i < rows; i++)
    {
        data[i] = new double[cols];
        for (int j = 0; j < cols; j++)
        {
            data[i][j] = m.data[i][j];
        }
    }
    return *this;
}

ostream& operator<<(ostream& os, const Matrix& m)
{
    for (int i = 0; i < m.rows; i++)
    {
        for (int j = 0; j < m.cols; j++)
        {
            os << m.data[i][j] << "\t";
        }
        os << endl;
    }
    return os;
}

完整修改后代码示例 #

头文件（matrix.h） #

#pragma once
#include <iostream>
using namespace std;

class Matrix
{
private:
    int rows;
    int cols;
    double** data;

public:
    Matrix();
    Matrix(int zeilen, int spalten);
    Matrix(const Matrix& m);                  // Copy-Konstruktór
    ~Matrix();
    Matrix operator = (const Matrix& m);    // Zuweisungsoperator

    int setze_element(int zeile, int spalte, double wert);
    int zeilen() const;
    int spalten() const;

    // 友元函数实现输出运算符重载
    friend ostream& operator<<(ostream& os, const Matrix& m);
};

CPP文件（matrix.cpp） #

#include "matrix.h"
#include <iostream>
#include <cstdlib> // 用于EXIT_FAILURE

using namespace std;

Matrix::Matrix() : rows(0), cols(0), data(nullptr) {}

Matrix::Matrix(int zeilen, int spalten) : rows(zeilen), cols(spalten)
{
    data = new double*[rows];
    for (int i = 0; i < rows; i++)
    {
        data[i] = new double[cols]();
    }
}

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

Matrix::~Matrix()
{
    if (data != nullptr)
    {
        for (int i = 0; i < rows; i++)
        {
            delete[] data[i];
        }
        delete[] data;
    }
}

Matrix Matrix::operator=(const Matrix& m)
{
    if (this == &m) return *this;

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

    rows = m.rows;
    cols = m.cols;
    data = new double*[rows];
    for (int i = 0; i < rows; i++)
    {
        data[i] = new double[cols];
        for (int j = 0; j < cols; j++)
        {
            data[i][j] = m.data[i][j];
        }
    }
    return *this;
}

int Matrix::setze_element(int zeile, int spalte, double wert)
{
    if (zeile >= 0 && zeile < rows && spalte >= 0 && spalte < cols)
    {
        data[zeile][spalte] = wert;
        return 1;
    }
    else
    {
        cout << "Zeile und Spalte liegt ausserhalb des gültigen Bereichs!" << endl;
        return 0;
    }
}

int Matrix::zeilen() const
{
    return rows;
}

int Matrix::spalten() const
{
    return cols;
}

ostream& operator<<(ostream& os, const Matrix& m)
{
    for (int i = 0; i < m.rows; i++)
    {
        for (int j = 0; j < m.cols; j++)
        {
            os << m.data[i][j] << "\t";
        }
        os << endl;
    }
    return os;
}

void belegen_m1(Matrix& m)
{
    double cmat[5][3] = { { 1.0, 0.0, 0.0 },
                          { 0.0, 2.0, 0.0 },
                          { 0.0, 0.0, 3.0 },
                          { 4.0, 0.0, 0.0 },
                          { 0.0, 5.0, 0.0 }
    };
    for (int z = 0; z < m.zeilen(); z++)
        for (int s = 0; s < m.spalten(); s++)
            if (m.setze_element(z, s, cmat[z][s]) == 0)
            {
                cout << "Fehler bei belegen_m1(), Abbruch" << endl;
                exit(EXIT_FAILURE);
            }
}

int main()
{
    Matrix m1(5, 3);
    belegen_m1(m1);
    cout << "m1:" << endl << m1 << endl;
    return 0;
}

内容的提问来源于stack exchange，提问作者Linas