c++ - 将运算符覆盖应用于具有动态分配指针的类

Question

我已经定义了MyString类，现在要实现加法操作。发生内存泄漏是很可怕的，所以我已经注意从析构函数中释放动态分配的指针。

#include <iostream>

class MyString {
private:
    int _size;
    char* _str;

public:
    MyString() {
        _size = 0;
        _str = nullptr;
    }

    MyString(int size, char* str) {
        _size = size;
        _str = new char[size + 1];
        strcpy(_str, str);
    }

    ~MyString() {
        delete[] _str;
    }

    void print() {
        std::cout << _str << std::endl;
    }

    friend MyString operator+(const MyString& lhs, const MyString& rhs);
};

MyString operator+(const MyString& lhs, const MyString& rhs) {
    char* temp = new char[lhs._size + rhs._size + 1];
    strcpy(temp, lhs._str);
    strcat(temp, rhs._str);

    MyString ret(lhs._size + rhs._size, temp);
    delete[] temp;
    return ret;
}

int main() {
    MyString first(5, "first");
    MyString second(6, "second");
    MyString add = first + second;

    first.print();
    second.print();
    add.print();
}

但是，如果我编译并运行代码，first.print() 和 second.print() 打印得很好，但是 add .print() 将打印垃圾值，然后崩溃(调试断言失败!)。

输出:

first
second
硼硼硼硼硼硼硼硼?흚 (and creashes :(.. )

如果我注释并运行析构函数，它打印良好，但会发生内存泄漏。为什么会这样？我看过几个运算符覆盖的例子，但我还没有找到这种动态分配指针的例子。

任何建议将不胜感激!

Answer 1

MyString operator+(const MyString& lhs, const MyString& rhs) {
    char* temp = new char[lhs._size + rhs._size + 1];
    strcpy(temp, lhs._str);
    strcat(temp, rhs._str);

    MyString ret(lhs._size + rhs._size, temp);
    delete[] temp;
    return ret;
}

在此函数的末尾，'ret' 被销毁，调用析构函数并删除缓冲区。返回的是从“ret”复制的 MyString 的新实例，其缓冲区指向与原始内存位置相同的内存位置。由于这已被删除，您现在打印出垃圾。

要解决此问题，您可以添加复制构造函数以确保复制缓冲区:

class MyString {

// Other class details
public:
    MyString(const MyString & other) : MyString(other._size, other._str) {}

// Other class details
}

这将确保在将一个 MyString 分配给另一个 MyString 时复制缓冲区。