为什么需要在 c++ 运算符重载中删除内存并分配新内存

为什么只是我无法更新现有内存中的值

如果 LHS 有足够的内存，则可以这样做。否则，您必须解除分配旧内存并分配新内存。

const MyString& operator=(const MyString& rhs)
{ 
   if (this != &rhs) {
      if ( this->length < rhs.length )
      {
         this->length = rhs.length;
         delete[] this->str;
         this->str = new char[strlen(this->length) + 1];
      }
      strcpy(this->str, rhs.str);
   }
   return *this;
}

仅当字符串长度超过已分配空间时，才需要分配新内存：rhs

MyString& operator=(const MyString& rhs) {  // don't return a `const&`
    if (this != &rhs) {
        if(length < rhs.length) {
            delete[] str;
            str = new char[rhs.length + 1];
        }
        length = rhs.length;
        std::memcpy(str, rhs.str, length + 1);
    }
    return *this;
}

请注意，如果不添加成员变量，这将丢失有关额外空间的信息。添加后，它看起来像这样：capacity

MyString& operator=(const MyString& rhs) { 
    if (this != &rhs) {
        if(capacity < rhs.length) {
            delete[] str;
            capacity = rhs.length;
            str = new char[capacity + 1];
        }
        length = rhs.length;
        std::memcpy(str, rhs.str, length + 1);
    }
    return *this;
}

演示

对于初学者来说，应该返回对分配对象的引用。也就是说，它应该像这样声明operator =

MyString & operator=(const MyString& rhs);

存储在类 MyString 的赋值对象中的字符串可以短于赋值对象中存储的字符串。在本例中，此语句

strcpy(this->str, rhs.str);

可能导致内存覆盖超出调用未定义 Bejavior 的已分配字符串。

请注意，没有必要调用标准函数，因为数据成员长度已经存储了字符串的长度。 运算符可以按以下方式定义。strlen

const MyString& operator=(const MyString& rhs)
{ 
    if ( this != &rhs ) 
    {
        if ( this->length != rhs.length )
        {
            delete[] this->str; // Why is this required?
            this->str = new char[rhs.length + 1];
            this->length = rhs.length;
        }
        strcpy( this->str, rhs.str );
    }

    return *this;
}

被复制的来源可以与被分配到的不同。MyStringlengthMyString

无法调整数组的大小。要创建不同大小的数组，必须销毁旧数组并将其替换为新数组。这就是第一个代码正在做的事情。

在第二个代码中，仅当新数组较小或相等时，才有意义重用现有数组，而您没有检查，例如：

const MyString& operator=(const MyString& rhs)
{ 
    if (this != &rhs) {
        if (rhs.length > this->length) {
            delete[] this->str;
            this->str = new char[rhs.length + 1];
        }
        strcpy(this->str, rhs.str);
        this->length = rhs.length;
    }
    return *this;
}

在这种情况下，您应该考虑添加另一个成员，以更好地区分为数组物理分配的 s 数与数组内部逻辑上有效的 s 数，例如：capacitycharchar

MyString()
    : str(NULL), length(0), capacity(0)
{
}

MyString(const MyString& src)
    : str(NULL), length(0), capacity(0)
{
    if (src.str) {
        this->capacity = rhs.length; // optionally round up to an even boundary of your choosing
        this->str = new char[this->capacity + 1];
        strcpy(this->str, src.str);
        this->length = rhs.length;
    }
}

const MyString& operator=(const MyString& rhs)
{ 
    if (this != &rhs) {
        if (rhs.length > this->capacity) {
            delete[] this->str;
            this->capacity = rhs.length;  // optionally round up to an even boundary of your choosing
            this->str = new char[this->capacity + 1];
        }
        strcpy(this->str, rhs.str);
        this->length = rhs.length;
    }
    return *this;
}