-4

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

编写一个类 TwoD，它在其构造函数中使用此显示的想法来实现二维动态双精度数组。您应该有一个指向 double 类型的私有成员以指向动态数组，以及两个 int（或无符号 int）值，它们是 MaxRows 和 MaxCols。您应该提供一个默认构造函数，您将为其选择默认的最大行和列大小，以及一个允许程序员设置最大行和列大小的参数化构造函数。此外，您应该提供一个允许设置特定行和列条目的 void 成员函数，以及一个将特定行和列条目作为 double 类型的值返回的成员函数。备注：重载 [ ] 很困难或不可能（取决于细节），因此它可以像您希望的那样用于二维数组。因此，只需使用普通函数表示法来使用访问器和修改器函数。将 + 运算符重载为友元函数以添加两个二维数组。此函数应返回 TwoD 对象，其第 i 行第 j 列元素是左侧操作数 TwoD 对象的第 i 行第 j 列元素与右侧操作数 TwoD 对象的第 i 行第 j 列元素之和。提供一个复制构造函数、一个重载的运算符 = 和一个析构函数。将不更改数据的类成员函数声明为 const 成员。左侧操作数 TwoD 对象的第 j 列元素和右侧操作数 TwoD 对象的第 i 行第 j 列元素。提供一个复制构造函数、一个重载的运算符 = 和一个析构函数。将不更改数据的类成员函数声明为 const 成员。左侧操作数 TwoD 对象的第 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;
}
4

2 回答 2

2

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

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

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

  4. 这本书听起来不太好。没有明显的原因，它在教不好的做法（ operator+ 技巧是标准的，unique_ptr如果你不能使用，你应该使用vector，等等等等）

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

  • 我有固定的复制构造函数，对吗？

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

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

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

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

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

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

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

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

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

于 2015-09-02T17:05:26.047 回答
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;

    ///
    /// 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;
}
于 2015-09-02T18:16:10.197 回答