using swap to make assignment operator exception safe

Hello everyone,


The following swap technique is used to make assignment operator exception safe (means even if there is exception, the current object instance's state is invariant).

It used a temporary object "temp" in this sample, and assignment is made on a to temp ar first. Even if there is exception, the current this object's state is not corrupted.

My question is, the pattern works only if there is no exception thrown by swap function. If there are exception in swap function, the state of current object instance may still be corrupted (swap may invoke the assignment operator of member variables). Is my understanding correct?

Code:

---

class A;
A& A::operator= (const A& a)
{
    A temp;
    temp = a; // exception may be thrown
    swap (*this, temp);
}

---

thanks in advance,
George

That's right.

However, isn't that implementation using assignment recursively (the commented line)? Rather the copy constructor is used (which may throw).

That's right, see: Chapter 51. Destructors, deallocation, and swap never fail

Thanks anon,


How to avoid the recursive issue in the swap-to-make-exception-safe pattern? :-)

Quote:

---

Originally Posted by anon

That's right.

However, isn't that implementation using assignment recursively (the commented line)? Rather the copy constructor is used (which may throw).

---

Thanks cpjust,


But the link does not contain information about how to design a no-exception throw swap function. :-)

Quote:

---

Originally Posted by cpjust

That's right, see: Chapter 51. Destructors, deallocation, and swap never fail

---

regards,
George

Code:

---

A& A::operator= (const A& a)
{
    A temp(a); //copy constructor
    swap (*this, temp);
}

---

I would write a member swap and then write either:

Code:

---

A& A::operator=(const A& a)
{
    A temp(a);
    swap(temp);
    return *this;
}

---

or:

Code:

---

A& A::operator=(const A& a)
{
    if (this != &a)
    {
        A temp(a);
        swap(temp);
    }
    return *this;
}

---

The second one would rarely be needed, since hopefully the member swap doesn't fail on swapping with your self and hopefully the member swap is relatively fast. If it wasn't fast, then using the swap technique would be a bit of a pessimization I would imagine, since you would be using the presumably slow copy constructor as well as the slow swap, rather than just implementing the copy assignment operator directly.

Member swap can be fast if you are swapping resources such as pointers between instances.

If you don't have such resources and shallow copying is all you need you don't need to implement operator= at all. That should take care of a majority of cases where swap-technique would be a pessimization?

It should always be obvious how to write a nothrow swap. If it is hard, then perhaps the class doesn't need a swap specialization (it has only shallow data), or there is a design error in the class.

But all resource-managing classes, which are the prime candidates for fast nothrow swaps, should contain some kind of resource handle. This handle should be easily swappable.

Thanks for all of you guys' help!


My question is answered.

Quote:

---

Originally Posted by CornedBee

It should always be obvious how to write a nothrow swap. If it is hard, then perhaps the class doesn't need a swap specialization (it has only shallow data), or there is a design error in the class.

But all resource-managing classes, which are the prime candidates for fast nothrow swaps, should contain some kind of resource handle. This handle should be easily swappable.

---

regards,
George