
The Anatomy of the Assignment Operator (1997) - yuashizuki
http://www.icu-project.org/docs/papers/cpp_report/the_anatomy_of_the_assignment_operator.html
======
conistonwater
Um, what's wrong with the simpler

    
    
        if (this == &that) return *this;
        TFoo tmp(that);
        swap(tmp);
        return *this;
    

(Assume swap does not throw, it's trivial to implement because swapping
pointers wouldn't throw.) This way the constructor of tmp takes care of
destroying partially-constructed objects and you don't need to do it by hand.
It seems like the clean up code just repeats what the compiler would
automatically generate for you in a constructor.

[This is from 1997, btw.]

~~~
Sharlin
Yes, the copy-and-swap idiom [1] is the classic "correct" (but somewhat
unintuitive) answer to this problem. It was probably not widely known in 1997,
though.

[1] [http://stackoverflow.com/questions/3279543/what-is-the-
copy-...](http://stackoverflow.com/questions/3279543/what-is-the-copy-and-
swap-idiom)

~~~
maxlybbert
According to the article, correctly implementing copy assignment wasn't widely
known either.

------
pdpi
It's an oft-quoted fact that Rust is meant to take stuff that good C/C++
programmers already do and build it into the language. If you weren't
convinced of this before reading this post, then pay close attention to how
important the author considers pointer ownership to be.

------
mainland
The first "correct" solution will leak memory if the call to
TSuperFoo::operator= throws an exception.

------
dietrichepp
And this is why we use C++11 wherever we can.

