Re: why is binding non-const ref to return value bad?

From:

"Johannes Schaub (litb)" <schaub-johannes@web.de>

Newsgroups:

comp.lang.c++

Date:

Wed, 10 Mar 2010 18:13:35 +0100

Message-ID:

<hn8jus$mec$00$2@news.t-online.com>

PeteUK wrote:

Hello,

I'm doing a code review for someone and picked them up on this:

BigClass AFunction() { /*returns a large object by value*/ }

Caller()
{
  BigClass bc = AFunction();
  /* use bc */
}

I saif they should do this in the caller to avoid copying the
temporary:

Caller()
{
  const BigClass& bc = AFunction();
  /* use bc */
}

This won't avoid a copy in current C++ more than it does if you remove the
reference.

They came back with the following code which compiled but I asked them
to change to const but I had trouble justifying why it should be
const:

Caller()
{
BigClass& bc = AFunction();
/* use bc */
}

Does the life of the temporary get extended using the non-const
reference as it does from using the const reference? Was I right to
pick him up on it not being const? Please give me some rationale if
I'm right!

You can justify by saying making it nonconst violates the C++ specs. A
temporary in itself has no bearing of being referenced by name after its
created. Having it able to bind to a const reference is a sort of workaround
to be able to accept both named object and the temporary. This can be seen
by noticing that the compiler may still copy the temporary - it doesn't try
to keep the temporaries' object identity the same.

If you need a modifiable object, then copy it into a local non-const, non-
reference variable.