Question about exception safety

Hello everybody!

I just stumbled into a part of the errata list for "Exceptional C++" by Herb
Sutter, which can be found at the following URL:
http://www.gotw.ca/publications/xc++-auto_ptr.htm

On this web site, Herb Sutter talks about auto_ptr and exception safety and
starts out with the following function, which does not give the strong
exception-safety guarantee of acting atomically, i.e. that even if there are
exceptions, either all side effects will happen or none of them will:

String f()
{
    String result;
    result = "some value";
    cout << "some output";
    return result;
}

The problem is that the following code invokes both the copy constructor and
the copy assigment operator of the String class, each of which may throw an
exception:

String theName;
theName = f();

So if either of the two copies fails, then all the side effects of f() will
have happened, but the result will be lost. In order to prevent this, Herb
Sutter first suggests to redefine f() as follows:

void f( String& result )
{
  cout << "some output";
  result = "some value";
}

However, he says that this solution wasn't any better because the assignment
in the last line may fail, thus leaving us with only one side effect
completed. Herb Sutter eventually comes up with an exception safe
implementation of f() that looks like this:

auto_ptr<String> f()
{
  auto_ptr<String> result = new String;
  *result = "some value";
  cout << "some output";
  return result;
      // rely on transfer of
      // ownership; this can't throw
}

I agree that this is an exception safe solution supporting the commit or
rollback behaviour Herb Sutter wants to achieve. However, I wonder if it
would not have been easier to simply switch the first and second lines of
the function taking a non-const String& argument:

void f( String& result )
{
  result = "some value";
  cout << "some output";
}

Assuming that the output of the string in the last line cannot throw, what
could go wrong here with regards to exception safety and the requirement of
the function to either succeed or have no effect? If the assignment in the
first line fails, then the String that was passed will be left unchanged.
(Unless of course, String's assigment operator itself is not atomic.) So the
function is a lot less complex than Herb Sutters final solution and
everything should be fine. What am I missing?

--
Matthias Hofmann
Anvil-Soft, CEO
http://www.anvil-soft.com - The Creators of Toilet Tycoon
http://www.anvil-soft.de - Die Macher des Klomanagers

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]