Re: how to reuse a copy constructor in an operator = function
On 3 nov, 06:58, James Kanze <james.ka...@gmail.com> wrote:
On Nov 2, 10:30 pm, Elias Salom=E3o Helou Neto <eshn...@gmail.com>
wrote:
[...]
MyClass& MyClass::operator=( const MyClass& rhs )
{
MyClass temp( rhs ); //Reusing copy constructor code.
this->swap( temp );
return( *this );
}
Notice that this may be sub-optimal because some instructions
in the copy constructor will be much the same than some in the
swap() method.
It may be sub-optimal, because the normal implementation of swap
will invoke the assignment operator. Infinite recursion is
definitely sub-optimal. Obviously, you need a special
implementation of the swap function, which doesn't use the
assignment operator. In practice, this idiom is only useful if
all of the sub-elements support a no-throw swap. This is the
case for the containers in the standard library, and should be
the case for most new code, provided the authors have kept
themselves up to date, but there is an awful lot of code
floating around where it is not the case.
Even if the assignement operator (for the actual class) is not used in
the swap member (and it cannot be, because it does not exist,
remeber?), this will be sub-optimal because many fields will be
assigned (with their assignement operator) in the copy constructor,
only to be reassigned then, via the swap member. With a
straightforward (without trying to reuse the copy constructor)
implementation of operator= this would not be needed. I was not even
thinking about infinite recursion.
If one could assign to the this pointer, things could be made
easier, even without that swap() method.
You'll have to explain that one to me. Assigning to the this
pointer would be tandamount to moving the object somewhere else
in memory, no?
Somehow, yes.
This raises the question: why isn't the this pointer a valid
lvalue?
Because it doesn't make sense to make it one. What would it
mean if you changed the value of the this pointer?
It does make sense: I could change the this pointer to point to
another object of the same (or even derived) classes, without the
placement new hassle. Placement new, as I see, is meant to be used to
ensure correct placement of the object when it is needed. In this case
it ended up being used as a workaround because this is not an lvalue
(not quite that, keep on reading). Would not the case (b) from Kai-Uwe
Bux be better if written like the following?
T& T::operator= ( T const & t ) {
T *copy = new T( *this ); //Reuses copy ctr.
T *temp;
temp = this;
this = copy; //Not c++!
delete temp;
return ( *this );
}
The main issue here is that it would invalidate any pointer/reference
to the object, and it is definitely dangerous. If this is the case for
your class (and it will be to most classes), Kai-Uwe Buxs solution is
definitely better, even if not perfect.
The point is that in some, though rare, cases assigning to the this
pointer makes sense. It would, however, be extremely dangerous and
perhaps the standard is right about avoiding it.
Elias Salom=E3o Helou Neto.