On 4/12/07 6:21 PM, in article
1176422460.558589.322...@y80g2000hsf.googlegroups.com, "Mathias Gaunard"
<loufo...@gmail.com> wrote:
Here is a crazy idea that I just came up with.
I was thinking of the issue caused by the unneeded temporaries that
happened when returning std::string by value.
std::string foo()
{
std::string s;
/* some work on s */
return s;
}
std::string s = foo(); // with a smart compiler doing NRVO, no
unneeded copy, construction or destruction
s = foo(); // constructs a tempory, calls s.operator=, then destructs
the temporary
The "named return value optimization" (NRVO) can eliminate the temporary in
the second example as well. Specifically, the NRVO optimization eliminates
the need for a temporary by extending the lifetime of the local variable
that foo() returns to be just as long as the lifetime of the temporary that
foo() would have ordinarily returned. In other words, the local variable
that foo() returns - and the temporary that holds foo()'s result (and whose
contents are copied into "s") - are one and the same.
A possible solution would simply to write the function that way so
that another string could be reused:
void foo(std::string& s)
{
s = ""; // to make it empty and forget about the old contents
/* some work on s */
}
This interface for foo() is inconvenient (and inefficient) whenever the
value to be transformed is either const or otherwise needs to be preserved.
A more convenient interface for foo() would separate input from output - and
would accept input by const reference as produce output by return value. And
thanks to the NRVO, the more convenient interface could well be the more
efficient interface as well.
OTOH it is very efficient when we want to reuse the string storage.
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]