Boost logo

Boost :

Subject: Re: [boost] Improving the assignment operators of various Boosttypes
From: David Abrahams (dave_at_[hidden])
Date: 2008-09-11 09:59:48

on Thu Sep 11 2008, Gevorg Voskanyan <> wrote:

> David Abrahams wrote:
>> on Wed Sep 10 2008, "Scott McMurray" wrote:
>> > On Wed, Sep 10, 2008 at 21:23, Joe Gottman wrote:
>> >> Joel Falcou wrote:
>> >>>
>> >>> I may come late and maybe like an unwanted guest in this discussion but I
>> >>> am curious to know how i can know that for a given class of mine, the swap
>> >>> value operator= is better than the by const ref operator= ?
>> >>>
>> >>
>> >> My rule of thumb is that if your assignment operator might throw an
>> >> exception and you want assignment to fulfill the strong exception safety
>> >> guarantee (i.e. either the assignment succeeds or the target remains
>> >> unchanged) then you should consider the swapping operator=.
>> >>
>> >
>> > I would even go slightly more expansive than that and say "Use the
>> > swapping operator= unless you've explicitly decided you want less
>> > exception safety (like for efficiency reasons in std::vector)".
>> >
>> > It means one fewer place that needs updating when members change, and
>> > I suspect -- though I have no supporting data -- that the optimizer
>> > should make the swapping version "good enough" in most cases.
>> Swapping and taking the parameter by value are orthogonal issues; the
>> latter has only to do with copy elision and not with exception safety.
>> Please see this thread:
> AFAIU, a swapping assignment operator taking the parameter by const ref adheres
> to the strong exception safety guarantee, whereas the one taking the parameter
> by value fulfills the nothrow guarantee. Not sure how practical and/or relevant
> the difference in this context is, though.
> Is my observation above correct?

Well, technically, yeah... although the expression that does the
assignment can still throw, so I don't think it makes much difference to
say that it's nothrow. In other words, if I give you

    f(std::string); // nothrow
    g(std::string&); // strong guarantee

For all practical purposes, you know that f and g have equivalent
exception behavior because std::string's copy ctor can throw.
I think this calculus might get more interesting when rvalue references
are involved, because you can actually write stronger conditional

Dave Abrahams
BoostPro Computing

Boost list run by bdawes at, gregod at, cpdaniel at, john at