创建复制构造函数时如何正确重载 operator=

Question

I was having a lecture at my University for C++, and I couldn't really understand what the operator= is supposed to do and how to overload it properly. In almost all examples from lectures that i could find, the part of the code for the copy and move constructor would look like this:

class MyClass {
MyClass(const MyClass& s) {
copy(s); // the function is supposed to do the copying.
}
MyClass& operator=(const MyClass& s){
if(this != &s){ remove(); copy(s);} // the remove function is defined later on in the code, and it 
           return *this;}                            deletes a given pointer.   

Now my question is, why is there an if statement her and what it does it do, and is there another way to properly overload the operator=, and why are we returning a class reference in the operator overload? Would be a mistake if we return it by value and not by reference? Also when is it a bad idea to copy things because I have read a lot about how copying can lead to memory leak, but i've never seen such an incident so I don't know what to make of it. Any help would be gladly appreciated!

Answer 1

This has nothing to do, whatsoever, with copy constructors.

This is checking for an edge case when an object gets assigned to itself:

MyClass c;

// Some code

c=c;

c=c is perfectly valid C++. You can assign an object to itself. Presumably, you expect this to do nothing. This object doesn't change.

The comparison to this in the assignment operator is done when the assignment operator itself would break horribly if the copy constructor gets called for self-assignment. If, in this case, s is the same object as this .

There is no law that says that assignment operator must make this comparison. Many assignment operator overloads work perfectly fine, as is, even when assigning the object to itself.

But whatever this assignment operator does, it won't work if the assignment is from itself. You failed to show what this assignment operator does, but the fact that it calls something called remove is a big honking clue. It removes something from the object, so without this check, assigning this object to itself would, otherwise, make it completely "empty". Which would be a rather rude thing to do, wouldn't you agree?

Answer 2

There was once an outdated idiom called Rule of Big 3 . The recommended implementation of that rule was another outdated Copy+Swap Idiom . Those idioms make good starting points for beginner C++ programmers. Later you may find out better trade-offs and optimized alternates for special cases. For now, sticking to the old idioms - at least - can improve guarantees for functionality and correctness of your code.

cheers, FM.