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

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 11 Mar 2010 15:55:40 -0800 (PST)

Message-ID:

<7553a853-631b-4e85-8d2f-847698303ad4@33g2000yqj.googlegroups.com>

On Mar 10, 5:08 pm, PeteUK <newbar...@gmail.com> wrote:

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 */
}

I'd disagree with that recommendation. There will normally be
the same number of copies, and the latter is just more verbose
and slightly less clear. It's also dangerous if at some later
date, AFunction is modified to return a const 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 */
}

The simple answer is: because the standard says so.

Does the life of the temporary get extended using the
non-const reference as it does from using the const reference?

Nothing to do with lifetimes. You can't use a temporary to
initialize a non-const reference.

Was I right to pick him up on it not being const? Please give
me some rationale if I'm right!

It won't compile if the reference isn't const. It that a
sufficiently good reason?

--
James Kanze