Re: assignment operator implementation
Andrei Alexandrescu (See Website For Email) wrote:
Carlos Moreno wrote:
dasjotre wrote:
I frequently see operator= implemented
through copy constructor + swap
[...]
It seems rather wasteful.
Appearances deceive! :-)
Let's see... Imagine a simple String class ... What would
the assignment operator do that you'd find non-wasteful??
He's got a point. Implementing String operator= as copy-and-swap can be
wasteful if the target string already has enough capacity. In that case,
it's faster to simply copy data over instead of doing an extra
allocation and deallocation.
Exception safety has a price, no doubt about it. The copy-and-swap idiom
is safe and elegant, but it must be understood that it comes with a
price tag.
Andrei
I think applying the label of costly to copy-and-swap is premature.
While it is wasteful in the particular instance of assigning a string
with less characters than the assigned-to string's allocation, as
Joshua Lehrer pointed out above, implementing the copy and swap as:
c& operator=(c tmp) {
swap(tmp);
return *this;
}
can avoid double-creating a temporary in cases of implicit conversion.
For this, all assignments are one copy-creation of a c-object plus
three assignments. The "classic" assignment operator:
c& operator=(const c& tmp);
in case of implicit conversion is going to create that temporary
anyways, and then do something that probably takes a lot longer than a
swap. And while a solution might be adding an additional copy
constructor for types that implicitly convert (like adding a const char
* assignment operator to string), doing this is impractical in an
implicit-heavy programming idiom, like one utilizing Proxy Objects.
I think we have to consider the special case where we assign to a
string with enough capacity like the case where we self-assign: Is
added efficiency worth the check? I agree that it is most likely worth
more than the self assignment, but is it worth more than other factors,
like the implicit conversion case?
Frederick Gotham wrote:
I disagree with both of you. The placement new option is efficient:
#include <new>
MyClass &operator=(MyClass const &rhs)
{
if (this != &rhs)
{
this->~MyClass();
::new((void*)this) MyClass(rhs);
}
}
--
Frederick Gotham
This would take just as long as copy-and-swap (longer if there's an
implicit conversion), and instead of offering the strong guarantee, it
offers what could only be termed as the die horribly guarantee. Like,
if MyClass had some dynamic memory it released on destruction without
setting the pointer to NULL ...
Todd Gardner
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]