赋值运算符重载问题

Question

这个问题让我很困惑。第一段代码工作正常，没有崩溃，它将 s1 分配给 s2 完美。但第二组代码导致程序崩溃。

任何人都知道为什么会发生这种情况或问题可能是什么？

代码 1：（有效）

    s1.add(10, 30, 25, "Test Screen", false);
s1.add(13, 10, 5, "Name:XXX", false);
s1.add(13, 18, 30);
s1.remove(-1);
Screen s2 = s1;

代码 2：（赋值时崩溃）

    Screen s1;

    if (1 != s1.add(10, 30, 25, "Test Screen", false))
        message("first add() has a problem");
   else if (2 != s1.add(13, 10, 5, "Name:XXX", false))
        message("second add() has a problem");
    else if (3 != s1.add(13, 18, 30))
        message("third add() has a problem");
    else if (3 != s1.remove(-1))
       message("first remove() has a problem");
    else {
        Screen s2 = s1;
}

屏幕类的赋值运算符：

        Screen& operator=(const Screen &scr) {
        if (this != &scr){
            for (int i = 0; i < 50; i++) {
                if  (fields[i])
                    delete fields[i];
                fields[i] = new LField();
            }

            for (int i = 0; i < scr.numOfFields; i++)
                fields[i] = scr.fields[i];

            numOfFields = scr.numOfFields;
            currentField = scr.currentField;
        }
        return *this;
    }

字段类的赋值运算符：

LField& operator=(const LField &lfieldobj) {
        if (this != &lfieldobj) {

            if (lfieldobj.val) {
                if (val)
                    delete[] val;
                val = new char[strlen(lfieldobj.val) + 1];
                strcpy(val, lfieldobj.val);
            }
            else{
                //val = new char[1];
                val = "";
            }
            rowNum = lfieldobj.rowNum;
            colNum = lfieldobj.colNum;
            width = lfieldobj.width;
            canEdit = lfieldobj.canEdit;
            index = lfieldobj.index;

        }
        return *this;
    }

任何输入将不胜感激:)

Answer 1

删除当前的 val 并将其替换为 std::string。删除您的字段并将其替换为std::vector。这应该可以让您消除两个重载的赋值运算符；编译器将提供有效的。我猜你会消除内存管理问题以及代码。

就目前而言，即使您“修复”了您所知道的内存管理问题，您也将面临这样一个事实：您的代码在面对异常时是完全不安全的（并且使用 new 所以它基本上也无法避免异常）。

Answer 2

        for (int i = 0; i < scr.numOfFields; i++)
            fields[i] = scr.fields[i];

这是不行的，您正在复制指针而不是指向的值。需要深拷贝。

Answer 3

什么是成员“字段”声明？

LField* 字段[50]？

如果是这样，谁将左侧对象字段成员初始化为NULL？我想说没有人...赋值运算符就像 C++ 中的复制构造函数，并且您在无效指针上调用删除。

Answer 4

该行

Screen s2 = s1;

实际上调用了 Screen 复制构造函数，而不是赋值运算符重载。

例如：

#include <iostream>
using namespace std;

class Screen
{
public:
        Screen() { }

        Screen(const Screen& s)
        {
                cout << "in `Screen::Screen(const Screen&)`" << endl;
        }

        Screen& operator=(const Screen& s)
        {
                cout << "in `Screen::operator=(const Screen&)`" << endl;
                return *this;
        }
};

int main()
{
        Screen s1;
        Screen s2 = s1;
}

打印：

在Screen::Screen(const Screen&)

中

我猜测您的 Screen 复制构造函数的定义类似于 Screen::operator=(const Screen&)，因此可能还需要将赋值运算符重载的修复应用于复制构造函数定义。

另外，Screen 的 fields 成员是如何定义的？如果是这样：

LField* fields[50];

那么在构造函数中，您必须将数组中的所有 LField* 对象初始化为 NULL 因为它们具有未定义的初始值：

std::fill_n(fields, 50, static_cast<LField*>(NULL));

如果没有此初始化，测试即使 fields[i] 没有指向分配，if (fields[i]) 也可能对某些 i 成功，从而导致您的程序尝试删除未由new返回的指针。

Answer 5

我已经设法修复它。毕竟这是内存分配的问题:)

Answer 6

对于复杂的对象，最好使用复制和交换 idum。
这为您提供了一个具有强大异常保证（事务安全）的赋值运算符。但这也意味着您只需在一处（构造函数）考虑对象的复杂创建。

Screen& Screen::operator=(Screen const& rhs)
{
    Screen tmp(rhs);
    this->swap(tmp);
    return *this;
}

void Screen::swap(Screen const& rhs) throw ()
{
     // Swap each of the members for this with rhs.
     // Use the same pattern for Field.
}