Apply operator overriding to classes with dynamic allocation pointers

Question

I have defined the MyString class, and now I want to implement the addition operation. It's horrible for memory leaks to occur, so I've taken care of releasing the dynamically allocated pointers from the destructor.

#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();
}

However, if I compile the code and run it, the first.print() and second.print() is printed well, but the add.print() will print the garbage value, and crashes (Debug Assertion Failed!).

Output:

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

If I annotate and run the destructor, it prints well, but a memory leak occurs. Why is this happening? I have looked at several examples of operator overriding, but I have not found an example of this dynamic allocation of pointers.

Any suggestion will be highly appreciated!

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;
}

At the end of this function 'ret' is destroyed which calls the destructor and deletes the buffer. What is returned is a new instance of MyString that was copied from 'ret', and its buffer points to the same memory location as the original. Since this has been deleted you are now printing out garbage.

To fix this you can add a copy constructor to ensure the buffer is copied:

class MyString {

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

// Other class details
}

This will ensure the buffer is copied when one MyString is assigned to another MyString.