Why do we need the delete statement?
const MyString& operator=(const MyString& rhs)
{
if (this != &rhs) {
delete[] this->str; // Why is this required?
this->str = new char[strlen(rhs.str) + 1]; // allocate new memory
strcpy(this->str, rhs.str); // copy characters
this->length = rhs.length; // copy length
}
return *this; // return self-reference so cascaded assignment works
}
This is not a copy constructor, it's the assignment operator. You need the deleted because the object being assigned is holding already a previous value.
This code is also not really good because first deletes the old value and then allocates the new one... but the allocation may throw an exception and in this case the object will keep a pointer to a deallocated area. A better approach is first allocate and then delete the old value (an exception should never be allowed to escape from a destructor... see this link for an explanation) so either the assignment succeeds or fails without compromising anything.
A common idiom is to implement a copy constructor and a swap operation (that swaps the contents of two instances guaranteeing that no exception will be thrown). Then you implement the assignment operator combining the two... this requires both less code and is robust from an exception handling point of view.
The answer is that you have to release the memory because if you didn't then it would be lost, since you are reusing the pointer for a new allocation. Anyway, if you are learning about operators, it is common to write operator= in terms of copy construction + no-throw swap:
class MyString {
char* str;
int len;
public:
MyString( const MyString& rhs ) : str( new char[ rhs.len ] ), len( rhs.len ) {
memcpy( str, rhs.str, len );
}
~MyString() {
delete str;
}
friend void swap( MyString & lhs, MyString & rhs ) throw() {
using std::swap;
swap( lhs.str, rhs.str );
swap( lhs.len, rhs.len );
}
MyString& operator=( MyString rhs ) { //note: by value
swap( *this, rhs );
return *this;
}
};
Note that the operations that are performed are the similar. Now the differences:
There is less overall code. Any operation that needs to be performed while copying will be implemented only in the copy constructor, the assignment operator borrows that code.
There is no need to check for self-assignment, as the copy is performed before the old memory is released
This implementation is exception safe: If there is a problem while allocating memory (or any other operation in the copy constructor) the operation has no side effects
Self assignment is less performant, as new memory is allocated, then copied and released. But assignment from temporaries (rvalue expressions) will be faster, as the compiler can elide the copy. Still performance should only be considered when and if measurements point at a bottleneck in the code.
That's not a copy constructor. That's just a copy operator. So this->str will be pointing to previously allocated memory. If that memory is not freed before this->str is given a new value, then it will never be freed since its only reference has been overwritten. As a consequence, without the delete statement, that method would leak memory.
Without the delete[] statement, you would be allocating memory without releasing it again. If your program is running sufficiently long, you would eventually run out of memory.
The new char[] call allocates new memory and yields a pointer to the allocated memory. You store this memory in this->str - overwriting the previous pointer stored in this->str.
Refer to Scott Meyers, Effective C++, 2nd Ed., Items 11 through 17 for a thorough treatment of the subject.
And also: stackoverflow
