I was just playing around with some test code I had done sometime ago and
found some behaviour I could not explain; looking up the C++11 standard
did me no good either.

It may be the std::string implementation - just guessing here.
So what do you think?

Platform: Ubuntu 12.04 LTS
Compiler: g++ 4.7.2
g++ cmdline: -ggdb -std=c++11 -Wall -Wextra -pedantic -fvisibility=hidden

Here are the code examples:

int main()
{
  std::string s1("Hello");
  std::string s2(" World");

  s1 + s2 = "Eh?";
  std::string  & sr = (s1 + s2 = "Eh?");

  //cout << sr << endl;

  std::string const & sr1(s1 + s2);

  cout << (s1 + s2 = "Eh?") << endl;
  cout << sr << endl;
  cout << sr1 << endl;

int main()
{
  std::string s1("Hello");
  std::string s2(" World");

  s1 + s2 = "Eh?";
  std::string  & sr = (s1 + s2 = "Eh?");

  cout << sr << endl;

  std::string const & sr1(s1 + s2);

  cout << (s1 + s2 = "Eh?") << endl;
  //cout << sr << endl;
  cout << sr1 << endl;

int main()
{
  std::string s1("Hello");
  std::string s2(" World");

  s1 + s2 = "Eh?";
  std::string  & sr = (s1 + s2 = "Eh?");

  cout << sr << endl;

  std::string const & sr1(s1 + s2);

  cout << (s1 + s2 = "Eh?") << endl;
  cout << sr << endl;
  cout << sr1 << endl;

int main()
{
  std::string s1{"Hello"};
  std::string s2{" World"};

  s1 + s2 = "Eh?";
  std::string const & sr{s1 + s2 = "Eh?"};

  cout << sr << endl;

  std::string const & sr1{s1 + s2};

  cout << (s1 + s2 = "Eh?") << endl;
  cout << sr << endl;
  cout << sr1 << endl;

Simon

--

the compiler sees:

operator=(s1+s2, "Eh?");

It evaluates s1+s2 as a temporary of type std::string and passes that
along with the second argument to the relevant operator=(). Where the
new features of C++11 cut in is in allowing (in this context) a
temporary to be bound to a non-const reference parameter

Am Mittwoch, 3. Oktober 2012 01:23:08 UTC+2 schrieb Simon Parmenter:

You might want to check out the following article as well:
http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-imp...

Cheers!
SG

Looks to me like s1 + s2 creates a temporary, to which "Eh?" is
assigned.  Anything after that is an accident of implementation.

When I've defined operator+ on my own objects, it returned a const
object, just to prevent this very thing.  I wonder why std::string
doesn't do that.

--jkl

Am 04.10.2012 20:40, schrieb James K. Lowden:
[..]

HTH & Greetings from Bremen,

Daniel Krügler

It also prevents usage patterns like 'f((s1+s2).replace(...).substr(...))'
which can be useful sometimes.

--
Seungbeom Kim

basic_string& operator= (basic_string other) &
{
    /*move guts from other*/;
    return *this;