三法则运动出乎意料的结果[重复]

Question

我尝试在空闲时间学习 C++ 基础并遵循一本书的练习。首先，当我输入 9 作为行和 8 作为列时，我得到 malloc freeing 错误。其次，我得到 0 作为输出，我看不到我输入的内容。我想编写程序，因为我可以加强三法则。这当然不是家庭作业。此外，我认为这是一个困难的问题和有效的问题。如果可以回答问题，那将很有帮助。因为我在谷歌上搜索过，所以我找不到关于解决方案的一半体面的东西。另外，你能检查一下我的复制构造函数、赋值运算符和析构函数，并告诉我我的错误在哪里吗？

写一个实现二维动态数组的类TwoD 在其构造函数中使用来自此显示的想法的双打。你 应该有一个指向 double 类型指针的私有成员指向 动态数组和两个 int（或 unsigned int）值 MaxRows 和 MaxCols。您应该为其提供一个默认构造函数 您将选择默认的最大行和列大小以及 允许程序员设置最大值的参数化构造函数 行和列的大小。此外，您应该提供一个 void 成员 允许设置特定行和列条目以及 返回特定行和列条目的成员函数 double 类型的值。备注：很难或不可能（取决于 在细节上）重载 [ ] 所以它可以按照您的意愿工作 二维数组。所以只需使用访问器和修改器函数 使用普通函数符号。将 + 运算符重载为好友 添加两个二维数组的函数。这个函数应该 返回 TwoD 对象，其第 i 行第 j 列元素是 左侧操作数 TwoD 对象的第 i 行第 j 列元素 以及右侧操作数 TwoD 的第 i 行第 j 列元素 目的。提供一个复制构造函数、一个重载的运算符 = 和一个 析构函数。声明不改变数据的类成员函数 作为 const 成员。

我的努力

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

class TwoD
{
public:
    TwoD();
    TwoD(int row, int column);
    void setRowCol();
    double getVal(int row, int column);
    friend const TwoD operator +(const TwoD& first, const TwoD& second);
    int getterRow() const;
    int getterCol() const;
    void setterRow(int row);
    void setterCol(int column);
    TwoD(const TwoD& object);
    TwoD& operator =(const TwoD& rightSide);
    void putArr() const;
    ~TwoD();
    static TwoD constructFromUserInput();
private:
    int MaxRows;
    int MaxCols;
    double **arr;
};

int main(int argc, char const *argv[])
{
    cout << "All size of TwoD object must be same\n\n";

    TwoD arr1 = TwoD::constructFromUserInput();
    TwoD arr2 = TwoD::constructFromUserInput();

    TwoD arr3;

    arr3 = arr1 + arr2;

    TwoD arr4(arr3);
    arr1.putArr();
    arr2.putArr();
    arr3.putArr();
    arr4.putArr();

    return 0;
}
void TwoD::setRowCol()
{
    int r_user;
    int c_user;
    cout << "Enter num of rows => ";
    cin  >> r_user;
    cout << "Enter num of columns => ";
    cin  >> c_user;

    MaxRows = r_user;
    MaxCols = c_user;

    TwoD(MaxRows,MaxCols);

}
TwoD::TwoD(int row, int column)
: MaxRows(row), MaxCols(column)
{
    arr = new double*[row];
    for (int i = 0; i < row; i++)
    {
        arr[i] = new double[column];
    }

    for (int i = 0; i < MaxRows; i++)
    {
        for (int j = 0; j < MaxCols; j++)
        {
            cout << "Enter for " << i << j << "=> ";
            cin  >> arr[i][j];
        }
    }
}
TwoD::TwoD()
: MaxRows(2), MaxCols(2)
{
    arr = new double*[2];
    for (int i = 0; i < 2; i++)
    {
        arr[i] = new double[2];
    }
}
double TwoD::getVal(int row, int column)
{
    return arr[row][column];
}
const TwoD operator +(const TwoD& first, const TwoD& second)
{
    TwoD sum;
    for (int i = 0; i < first.MaxRows; i++)
    {
        for (int j = 0; j < first.MaxCols; j++)
        {
            sum.arr[i][j] = first.arr[i][j] + second.arr[i][j];
        }
    }
    return sum;
}
TwoD::TwoD(const TwoD& object)
{
    MaxRows = object.MaxRows;
    MaxCols = object.MaxCols;

    arr = new double*[MaxRows];
    for (int i = 0; i < MaxRows; i++)
    {
        arr[i] = new double[MaxCols];
    }

    for ( int i = 0; i < MaxRows; i++ )
    {
        for ( int j = 0; j < MaxCols; j++ )
        {
            arr[i][j] = object.arr[i][j];
        }
    }
}
TwoD::~TwoD()
{
    for (int i = 0; i < MaxRows; i++)
        delete [] arr[i];
    delete [] arr;
}
TwoD& TwoD::operator =(const TwoD& rightSide)
{
    if (this == &rightSide)
    {
        return *this;
    }

    for (int i = 0; i < MaxRows; i++)
        delete [] arr[i];
    delete [] arr;

    arr = new double*[rightSide.MaxRows];
    for (int i = 0; i < rightSide.MaxRows; i++)
    {
        arr[i] = new double[rightSide.MaxCols];
    }

    MaxRows = rightSide.MaxRows;
    MaxCols = rightSide.MaxCols;

    for (int i = 0; i < MaxRows; i++)
    {
        for (int j = 0; j < MaxCols; j++)
        {
            arr[i][j] = rightSide.arr[i][j];
        }
    }
    return *this;
}
void TwoD::putArr() const
{
    for (int i = 0; i < MaxRows; i++)
    {
        for (int j = 0; j < MaxCols; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}
int TwoD::getterRow() const
{
    return MaxRows;
}
int TwoD::getterCol() const
{
    return MaxCols;
}
void TwoD::setterRow(int row)
{
    MaxRows = row;
}
void TwoD::setterCol(int column)
{
    MaxCols = column;
}
TwoD TwoD::constructFromUserInput()
{
    int r_user;
    int c_user;
    cout << "Enter num of rows => ";
    cin  >> r_user;
    cout << "Enter num of columns => ";
    cin  >> c_user;

    // Construct an object.
    TwoD obj(r_user, c_user);

    // Return the object
    return obj;
}

Answer 1

1. 您的复制构造函数创建数组，但从不复制内容。 复制赋值运算符正确地做到了这一点。就此而言，您有大量重复的new[] 循环、几个delete[] 循环，并且您应该有两个复制循环。将这些因素分解为函数，您只需将它们正确处理一次。

2. sum 创建一个 default-sized 对象，然后可能会超出行和列维度。通常（简单且正确）的实现是创建左侧参数的本地副本（使用您在上面修复的复制ctor）并转发到operator+=。该运算符更容易正确。

3. 你有办法打印出这些矩阵。去做吧！到处做！这样可以很容易地查看问题出现在哪个阶段。

4. 这本书听起来不太好。它无缘无故地教不好的做法（operator+技巧是标准的，如果你不能使用vector等，你应该使用unique_ptr等）

---

编辑：我会在这里回复一些 cmets，因为他们有变成聊天会话的危险，我不想在这上面花更多时间。

• 我有固定的拷贝构造函数对吗？

  现在是弄清楚如何测试和调试代码的好时机。添加打印语句，使用调试器，将内容拆分为可以测试的函数，然后为它们编写测试。

• 你的意思是几个delete[] 循环和两个复制循环

  在您的代码中查找循环。我可以看到 3 个循环调用 new[]，它们基本上都在做同样的事情。我可以看到 2 个循环调用 delete[]，一个在析构函数中，一个在复制赋值运算符中。只需在您自己的代码中搜索 for 关键字！

• 我真的找不到打印矩阵的方法

  那么TwoD::putArr 是从哪里来的？诚然，ostream& operator<<(ostream&, TwoD const &) 会是一个更好的名字，但你写了它，所以你不妨使用它。

• 我无法将析构函数放入 main()

  您不能停止 main 完成时调用的析构函数 - 然后您的对象超出范围。只需在析构函数中放置一个断点，它就会被调用。

• 因为 arr 是私有的，我该如何测试？

  你仍然可以在调试器中看到它，你仍然可以打印内容（如上），你仍然可以从单元测试中调用getVal，你可以直接调用它public，直到你弄清楚你的问题

Answer 2

您的代码有问题：

void TwoD::setRowCol()
{
    int r_user;
    int c_user;
    cout << "Enter num of rows => ";
    cin  >> r_user;
    cout << "Enter num of columns => ";
    cin  >> c_user;

    MaxRows = r_user;
    MaxCols = c_user;

    ///
    /// This constructs a new TwoD object but does not change
    /// object on which the function was invoked.
    ///
    TwoD(MaxRows,MaxCols);    
}

解决问题的方法：

更新会员资料

void TwoD::setRowCol()
{
    int r_user;
    int c_user;
    cout << "Enter num of rows => ";
    cin  >> r_user;
    cout << "Enter num of columns => ";
    cin  >> c_user;

    // Delete the current memory
    for (int i = 0; i < MaxRows; i++)
    {
       delete [] arr[i];
    }

    delete [] arr;

    MaxRows = r_user;
    MaxCols = c_user;

    // Allocate new memory.
    arr = new double*[MaxRows];
    for (int i = 0; i < MaxRows; i++)
    {
       arr[i] = new double[MaxCols];
    }

    // Now read the data.
    for (int i = 0; i < MaxRows; i++)
    {
        for (int j = 0; j < MaxCols; j++)
        {
            cout << "Enter for " << i << j << "=> ";
            cin  >> arr[i][j];
        }
    }
}

创建一个返回全新对象的函数

我推荐这种方法。

首先，更新获取行和列的构造函数，使其没有任何代码从用户输入中读取数据。

TwoD::TwoD(int row, int column)
: MaxRows(row), MaxCols(column)
{
    arr = new double*[row];
    for (int i = 0; i < row; i++)
    {
        arr[i] = new double[column];
    }
}

其次，添加static成员函数，根据用户输入构造一个对象。

static TwoD constructFromUserInput();

并将其实现为：

TwoD TwoD::constructFromUserInput()
{
    int r_user;
    int c_user;
    cout << "Enter num of rows => ";
    cin  >> r_user;
    cout << "Enter num of columns => ";
    cin  >> c_user;

    // Construct an object.
    TwoD obj(r_user, c_user);

    // Now read the data.
    for (int i = 0; i < r_user; i++)
    {
        for (int j = 0; j < c_user; j++)
        {
            cout << "Enter for " << i << j << "=> ";
            cin  >> obj.arr[i][j];
        }
    }

    // Return the object
    return obj;
}

第三，使用main的新功能。

int main(int argc, char const *argv[])
{
   cout << "All size of TwoD object must be same\n\n";

   TwoD arr1 = TwoD::constructFromUserInput();
   TwoD arr2 = TwoD::constructFromUserInput();

   TwoD arr3;

   arr3 = arr1 + arr2;
   arr1.putArr();
   arr2.putArr();
   arr3.putArr();

   return 0;
}