矩阵实现类C ++中的内存管理

Question

好的，大家好，所以我正在实现一个类Matrix （就像线性代数中的矩阵一样），当遇到异常时，我遇到了一个特殊情况的奇怪问题。当要求用户从控制台输入矩阵数据时，程序会崩溃，如果！输入是从类中触发异常抛出的东西。我认为它一定是某种奇怪的内存泄漏，我似乎无法追查。

班上唯一的私人成员是：double** rows / int width / int height。 我只会告诉你我的类析构函数，导致问题的输入函数，以及我的主要函数：

〜矩阵（）

Matrix::~Matrix()
{
    if (rows)
    {
        for (int k = 0; k < height; k++)
        {
            delete[] rows[k];
        }
        delete[] rows;
        rows = 0;
    }
}

运算符＆GT;＆GT;过载

std::istream& operator>> (std::istream& in, Matrix &obj)
{
    if (obj.rows)
    {
        for (int i = 0; i < obj.height; i++)
        {
            delete[] obj.rows[i];
        }
        delete[] obj.rows;
        obj.rows = 0;
        obj.width = 0;
        obj.height = 0;
    }
    std::cout << "Input matrix data (enter 'q' to stop and 'n' to start new row):" << std::endl;
    std::string input = "";
    double data;
    obj.height = 1;
    obj.rows = new double* [obj.height];
    int temp_width = 0;                                  // can overflow for incredibily long rows ;Ds
    double* temp_row = 0;
    while (true)
    {
        std::cin >> input;
        std::istringstream inputStream(input);
        //fill current row
        if (inputStream >> data)
        {
            temp_width++;
            if (temp_width > obj.width)
            {
                obj.width = temp_width;
            }
            if (temp_width == 1)
            {
                obj.rows[obj.height - 1] = new double[temp_width];
                obj.rows[obj.height - 1][temp_width - 1] = data;
            }
            else //(temp_width > 1)
            {
                //store row without the new element
                temp_row = new double [temp_width - 1];
                for (int j = 0; j < temp_width - 1; j++)
                {
                    temp_row[j] = obj.rows[obj.height - 1][j];
                }
                //temp_row = obj.rows[obj.height - 1];
                delete[] obj.rows[obj.height - 1];
                obj.rows[obj.height - 1] = 0;   //probably not needed
                obj.rows[obj.height - 1] = new double[temp_width];

                //copy over the row from previous iteration
                for (int k = 0; k < temp_width - 1; k++)
                {
                    obj.rows[obj.height - 1][k] = temp_row[k];
                }
                //append the new element at the end of current row
                obj.rows[obj.height - 1][temp_width - 1] = data;
                delete[] temp_row;
                temp_row = 0;
            }
        }
        //add new row
        else if (input == "n")
        {
            //prevent creating new row if the current one is empty
            if (temp_width == 0)
            {
                throw InputError("You must enter at least one element per row.");
            }
            //stuff end of row with zeroes if needed
            else if (temp_width < obj.width)
            {
                temp_row = new double [temp_width];
                temp_row = obj.rows[obj.height - 1];
                delete[] obj.rows[obj.height - 1];
                obj.rows[obj.height - 1] = new double[obj.width];
                for (int i = 0; i < obj.width; i++)
                {
                    if (i > temp_width - 1)
                        obj.rows[obj.height - 1][i] = 0;
                    else
                        obj.rows[obj.height - 1][i] = temp_row[i];
                }
                delete[] temp_row;
                temp_row = 0;
            }
            //backup current matrix AND delete the original
            double** temp_matrix = new double* [obj.height];
            for (int k = 0; k < obj.height; k++)
            {
                temp_matrix[k] = new double [obj.width];
                for (int j = 0; j < obj.width; j++)
                {
                    temp_matrix[k][j] = obj.rows[k][j];
                }
                delete[] obj.rows[k];
            }
            delete[] obj.rows;
            obj.rows = 0;
            //generate the new bigger matrix, copy backup into it, delete backup
            obj.height++;
            obj.rows = new double* [obj.height];
            for (int s = 0; s < obj.height - 1; s++)
            {
                obj.rows[s] = new double [obj.width];
                for (int v = 0; v < obj.width; v++)
                {
                    obj.rows[s][v] = temp_matrix[s][v];
                }
                delete[] temp_matrix[s];
            }
            delete[] temp_matrix;
            temp_matrix = 0;
            temp_width = 0;
        }
        //exit input
        else if (input == "q")
        {
            if (obj.width == 0)
            {
                throw InputError("Input Error. You must enter at least one element into matrix");
            }
            //stuff with zeroes if needed
            if (temp_width < obj.width)
            {
                temp_row = new double [temp_width];
                temp_row = obj.rows[obj.height - 1];
                delete[] obj.rows[obj.height - 1];
                obj.rows[obj.height - 1] = new double[obj.width];
                for (int i = 0; i < obj.width; i++)
                {
                    if (i > temp_width - 1)
                        obj.rows[obj.height - 1][i] = 0;
                    else
                        obj.rows[obj.height - 1][i] = temp_row[i];
                }
            }
            break;
        }
        //throw input error
        else
        {
            throw InputError("Input Error. Only numbers and the characters 'n' and 'q' are accepted");
        }
    }
    return in;
}

主要（）

int main()
{
    bool tryAgain = true;
    Matrix m1;
    while (tryAgain)
    {
        try
        {
            cin >> m1;
            cout << "Matrix 1: \n" << m1;
        }
        catch (InputError& e)
        {
            cout << e.what() << endl;
        }
        cout << "Enter matrix data again? (y/n) ";
        char input;
        cin >> input;
        if (input == 'n') tryAgain = false;
    }
    return 0;
}

如果您觉得彻底浏览我的运营商太麻烦了＆gt;＆gt;函数只是采用程序将粉碎的最简单的情况。当用户的第一次输入不是数字或“q”和“n”之一时，就是。这由运算符＆gt;＆gt;中的最后一个else语句处理。功能。确切的结果是在控制台中您看到抛出的异常，然后main（）函数的while循环继续。当它第二次循环回cin >> m1;语句时，无论输入是什么，您只是得到一条消息 - “此应用程序已请求运行时终止它......”。有时你甚至不需要第二次输入任何东西而且在此之前它会崩溃。有任何想法吗？

Answer 1

您遇到的问题取决于您的内存管理选择，我认为这是根本不正确的，因为您没有对矩阵进行建模，而是一个带有整个非连续内存的锯齿状边缘结构。 （例如，写作转置方法将是您设计选择的噩梦。）

此处有两条路线：

1）用一块内存重新设计你的课程;建议（从零开始）元素（i，j）保持在i * rows + j，其中rows是矩阵中的行数。您可以将[] []替换为对double& operator()(unsigned i, unsigned j)和const double& operator()(unsigned i, unsigned j) const形式的重载运算符的调用。 （提供了参考，因此您可以使用（，）作为左值;例如myMatrixObject(i, j) = 1.0）

2）使用BLAS中的矩阵类（可从www.boost.org获得）。其中包含稀疏矩阵和标识矩阵等实现。

我更喜欢（2）。我知道构建自己的矩阵类很有趣但是“不要重新发明轮子”确实让人想起。

Answer 2

使用矢量。他们管理自己的内存，测试溢出并轻松地允许您添加新元素。在这种情况下，您需要一个向量矢量来表示二维数组。我不能为你把它包在课堂上，但这是基本的想法。

vector< vector< double > > data;
// height
data.resize(10);
// width
for (vector< vector< double > >::iterator it = data.begin(), end_it = data.end(); it != end_it; ++it)
{
    it->resize(5);
}

// access element, notice X/Y reversed (it's more efficient this way)
int x = 3;
int y = 4;
double d = data[y][x];

// add extra element to row
data[y].push_back(d);