1

我一直在尝试添加两个二维数组。在我为“=”添加重载函数后，C++ 开始崩溃一次。编译器只是崩溃。但是没有添加

cout << "combining the two is" << endl;
example3 = example1 + example2;
example3.outPut();

并禁用重载运算符成员函数，一切正常。
能否请你帮忙？

enter code here

#include <iostream>
using namespace std;
#include <string>
#include <fstream>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <windows.h>
#include <cstring>
#include <cctype>
#include <iomanip>
#include <algorithm>
#include<sstream>


class TwoD
{
private:
int MaxRows;
int MaxCols;
double** outerArray;

public:
TwoD(int maxRows, int maxCols)
{
    MaxRows = maxRows;
    MaxCols = maxCols;
    outerArray = new double *[MaxRows];
    for (int i = 0; i < MaxRows; i++)
        outerArray[i] = new double[MaxCols];
}

void input()
{
    for (int k = 0; k < MaxRows; k++)
        for (int j = 0; j < MaxCols; j++)
            cin >> outerArray[k][j];
}

void outPut()
{
    for (int l = 0; l < MaxRows; l++)
    {
        for (int m = 0; m < MaxCols; m++)
            cout << outerArray[l][m] << " ";
        cout << endl;
    }
}

const TwoD operator = (const TwoD& rightSide)
{
    for (int l = 0; l < MaxRows; l++)
    {
        for (int m = 0; m < MaxCols; m++)
            outerArray[l][m] = rightSide.outerArray[l][m];
        cout << endl;
    }

    return *this;
}



const TwoD operator + (const TwoD& rightSide)
{
    for (int l = 0; l < MaxRows; l++)
    {
        for (int m = 0; m < MaxCols; m++)
            outerArray[l][m] = outerArray[l][m] + rightSide.outerArray[l][m];
        cout << endl;
    }

    return *this;
}

~TwoD()
{
    for (int i = 0; i < MaxRows; i++)
        delete[] outerArray[i];
    delete[] outerArray;
}

};

int main()
{
TwoD example1(3, 3), example2(3,3), example3(3,3);
cout << "input example1" << endl;
example1.input();
example1.outPut();

cout << "input example2" << endl;
example2.input();
example2.outPut();

cout << "combining the two is" << endl;
example3 = example1 + example2;
example3.outPut();


return 0;
}
4

3 回答 3

3

对于class/struct动态分配内存的，你需要遵循三规则。

class TwoD
{
public:
   TwoD(const TwoD& other);             // copy constructor
   TwoD& operator = (const TwoD& other) // copy assign operator
};

我建议你使用向量的向量来表示二维数组，你甚至不需要编写复制构造、内存管理等。

#include <vector>
struct TwoD
{
    std::vector<std::vector<double> > outerarray;
};
于 2013-09-09T10:58:12.683 回答
3

编译器只是崩溃。

真的吗？对我来说，程序可以编译，但由于双重删除而在运行时崩溃。

能否请你帮忙？

要使类正确可复制：

  • 根据三规则，您需要一个复制构造函数和一个复制赋值运算符。您只有赋值运算符。
  • 赋值运算符应该返回一个引用，而不是一个副本。

一个合适的复制构造函数可能看起来像

TwoD(const TwoD& other) : TwoD(other.MaxRows, other.MaxCols)
{
    for (int l = 0; l < MaxRows; l++)
        for (int m = 0; m < MaxCols; m++)
            outerArray[l][m] = other.outerArray[l][m];    
}

（如果您不能使用 C++11 的委托构造函数，那么您需要复制默认构造函数的初始化，或者将其移出到两个构造函数调用的单独函数中）。

一旦有了复制构造函数，您可能会考虑使用复制和交换习惯用法来获得对异常更友好的赋值运算符。在 C++11 中，您还可以考虑使类可移动（通过将指针复制到目标，并使受害者中的指针无效），以避免在某些情况下进行不必要的内存分配。

另外，operator+不应该修改它的论点；它应该返回一个新创建的对象。您的实现更适合operator+=（尽管operator=应该返回引用，而不是副本）。

一旦您了解了手动内存管理的工作原理，您应该使用标准容器和智能指针等类来为您解决所有这些繁琐的问题。尤其std::vector是动态数组。

于 2013-09-09T11:04:30.130 回答
1

上一个答案是错误的，让我再试一次。

当您创建对象的副本时，您的矩阵不会被复制，只有指向它的指针被复制。这意味着您有多个对象，特别是这里的临时对象，当它们被破坏时，将删除矩阵，然后在函数结束时，您将再次删除它们。这是你的崩溃，双重免费。

您需要定义一个“复制构造函数”，它会以一种彬彬有礼的方式制作您的对象的真实副本，这就是 Billz 所指的，或者采取简单的方法并使用 C++ 库类vector来为您解决这个问题.

int MaxRows;
int MaxCols;
double** outerArray;

会成为

std::vector<std::vector<double> > matrix = new std::vector(MaxRows, new std::vector(MaxCols, 0.0))

vector您可以在 google 或http://en.cppreference.com/w/cpp/container/vector上阅读更多信息

于 2013-09-09T10:51:26.900 回答