Question

我目前有一个如下所示的赋值运算符：

CellPhoneHandler CellPhoneHandler:: operator=(const CellPhoneHandler &original){

   if (this->nrOfCellphones > 0)
        for (int i = 0; i < this->nrOfCellphones; i++) {
             delete this->cellphone[i];
   }


    delete[] cellphone;

    this->nrOfCellphones = original.nrOfCellphones;
    this->cellphone = new CellPhone*[this->nrOfCellphones];


    for (int i = 0; i<this->nrOfCellphones; i++) 
    {
        cellphone[i] = original.cellphone[i];
    }

    return *this;
}

然后在程序开始时，我打算测试它是否正常工作：

    CellPhoneHandler assignme;
assignme.addPhone("assignment phone", 500, 1000);
assignme.addPhone("assignment phone 2", 500, 1000);

copyme = assignme;

Hower，当我退出程序时，我得到了未处理的异常，它指向dbgdel.cpp中的第52行：

       /* verify block type */
        _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));

为什么有任何想法？这个问题似乎只存在于这个函数中，因为当我将测试从程序中注释掉时它才起作用。

我的CellPhone类看起来像这样：

    class CellPhone
{
private:
    string model;
    int stock;
    double price;
public:
    CellPhone(string model="", int stock=0, double price=0); // constructor
    string getModel()const;
    int getStock()const;
    double getPrice()const;
    void setModel(string model);
    void setStock(int stock);
    void setPrice(double price);
    string toString() const;
    ~CellPhone(); //destructor
};

将变量名称更改为原始名称，但错误仍然相同。

class CellPhoneHandler
{

private:
    CellPhone **cellphone;
    int nrOfCellphones;

public:
    CellPhoneHandler();
    CellPhoneHandler(const CellPhoneHandler &original); 
    CellPhoneHandler operator=(const CellPhoneHandler &original); 
    void addPhone(string model, int price, int stock);
    ~CellPhoneHandler();
    string showByStock(int stock) const;
    void removeModel(string model);
    void changePriceProcent(double procent, int price);
    void showAll(string array[], int nrOfCellphones) const;
    void saveToFile(string fileName) const;
    void readFromFile(string fileName);
    int getNrOfPhones()const;
};

更新：将我的operator =更改为此简化代码：

CellPhoneHandler CellPhoneHandler:: operator=(const CellPhoneHandler &original){
CellPhoneHandler tmp(original);
swap(this->cellphone, tmp.cellphone);
swap(this-> nrOfCellphones, tmp.nrOfCellphones);

return *this;
}

程序现在可以正常工作，但是这个是深入复制吗？我的老师告诉我，我的最后一项任务没有那样做。

Answer 1

您的赋值运算符应返回CellPhoneHandler&，而不是CellPhoneHandler对象。通过返回一个对象，您将（不必要地）调用复制构造函数。

此外，您的赋值运算符无法检查自我赋值（将CellPhoneHandler对象分配给自身）。自我分配将最终删除对象的数据，然后尝试从已删除的内存区域进行复制。

如果对new[]的调用抛出异常，则赋值运算符也将失败。在发出对new[]的调用之前，您正在更改对象的内部，因此如果出现问题并且new[]抛出异常，则会破坏对象。

但是，您可以利用复制构造函数和析构函数来使用copy / swap idiom来实现赋值运算符，而不是编写所有这些代码来实现赋值运算符：

#include <algorithm>
//...
CellPhoneHandler& CellPhoneHandler:: operator=(const CellPhoneHandler &original)
{
    CellPhoneHandler temp(original);
    std::swap(temp.nrOfCellphones, nrOfCellphones);
    std::swap(temp.cellphone, cellphone);
    return *this;
}

现在通过创建临时对象来使用复制构造函数，并且只使用当前对象的内部交换临时对象的内部。然后临时对象消失。

这是异常安全的（因为如果构造temp出现任何问题，原始对象没有任何问题），也不需要检查自我分配（你可以做一个可能的优化，但不需要实际执行此检查，与您对赋值运算符的原始尝试不同。）

类中的赋值运算符，_ASSERTE（_BLOCK_TYPE_IS_VALID（pHead-＆gt; nBlockUse））;

1 个答案: