C++ Assignment overload self-assignment issue - c++

Question

I am currently working on an ADT called Text and I'm overloading the assignment operator. When I test the operator like so: assignText = alpha everything outputs okay. However, when I do assignText = assignText then two solid bars output instead.
assignText is declared as a Text object.
My overloaded assignment operator is as follows:
void Text::operator= (const Text& other) {
bufferSize = other.getLength();
buffer = new char[bufferSize];
buffer = other.buffer;
}
Where int bufferSize and char *buffer
Any tips or suggestions would be greatly appreciated. If anything else is needed, just let me know.

Answer 1

Other answers already have pointed out various issues with your operator implementation. Here I'll try to understand what's happening for you, i.e. why the code behaves as you observe. If this == &other, i.e. during self assignment, you take the current length as the size of a new buffer. That new buffer isn't initialized, so at that point it might contain random bytes. The last assignment is a no-op in case of a self-assigment. To sum things up:
void Text::operator= (const Text& other) {
bufferSize = other.getLength(); // Take length from current object
buffer = new char[bufferSize]; // Create new buffer, old buffer turns into a memory leak
buffer = other.buffer; // No-op as both are the same variable
}
So what this tells you is that you end up with a buffer of the current object size but with undefined content. In your case that undefined content happens to represent the vertical bars you mention.
To solve this, make sure to fix the assignment operator based on the suggestions from other answers and comments.

Answer 2

This is a memory leak. You're assigning two different pointers to buffer.
buffer = new char[bufferSize];
buffer = other.buffer;

Answer 3

Regarding the problem at hand, that's covered by the C++ FAQ: "Why should I worry about "self assignment"?". It's often a good idea to read the FAQ first. Or at least skim it.
When you absolutely have to implement a copy assignment operator, usually the copy-and-swap idiom will be good enough. It's also exception safe. Goes like this:
void swapWith( MyType& other ) throw()
{
// swap them members
}
void operator=( MyType other )
{
swapWith( other );
}
Here the copy constructor creates the formal argument copy, and any exception happens there, so that the copy constructor centralizes also the cleanup in case of copy failure. After that the contents of the two objects are swapped, and the copy object's destructor takes care of cleaning up what was this object's internal stuff. The void result type is not yet conventional, but as I see it it's not smart to waste both code and time on supporting expressions with side effects, which are evil.
Now, you can avoid all this, simply by using std::vector for your buffer.
So that's what I recommend, the really simple solution: use std::vector.

Answer 4

This is because your assignment operator is fundamentally unsafe. You need to break the old state as the last step. Consider
Text& Text::operator= (const Text& other) {
auto new_buffer = new char[other.bufferSize];
std::copy(other.buffer, other.buffer + other.bufferSize, new_buffer);
// Now consider whether or not you need to deallocate the old buffer.
// Then set the new buffer.
buffer = new_buffer;
bufferSize = other.bufferSize;
return *this;
}
This ensures that if any problems are encountered, it is guaranteed that the Text object is always valid- and as a bonus, is self-assignment-safe. All well-written assignment operators are self-assignment safe.
This is often tied with copy-and-swap, which copies, then swaps- guaranteeing safety.

Answer 5

This piece of code will work perfectly
Text& Text::operator=(const Text& other)
{
if(this == &other) /* checks for self assignment */
return *this;
if(NULL == other.buffer)
return *this;
if(NULL != buffer) /* assuming buffer=NULL in constructor */
{
delete [] buffer;
buffer = NULL;
}
bufferSize = other.getLength();
buffer = new char[bufferSize+1];
memset(buffer, 0, bufferSize+1);
memcpy(buffer, other.buffer, bufferSize);
return *this;
}
Try this..

Answer 6

After some thought and review, I think I got it. Given that I need to write a void function dictated by the header file that I must construct my implementation from. I took into consideration the comments from Drew Dormann, MvG, as well as others and came up with this:
void Text::operator= (const Text &other)
{
if (this != &other) // takes care of self-assignment
{
delete [] buffer; // delete the old buffer
bufferSize = other.bufferSize; // assign size variable
buffer = new char[bufferSize + 1]; // create new buffer
strcpy(buffer, other.buffer); // copy array
}
}
This works and I believe it is memory leak free.