Re: pros and cons of returning const ref to string instead of string by value

From:

Stuart Golodetz <sgolodetz@NdOiSaPlA.pMiPpLeExA.ScEom>

Newsgroups:

comp.lang.c++.moderated

Date:

Thu, 3 Dec 2009 11:21:39 CST

Message-ID:

<M5KdnWz23bDhLorWnZ2dnUVZ8oKdnZ2d@pipex.net>

Goran wrote:

On Dec 2, 10:58 pm, Stuart Golodetz
<sgolod...@NdOiSaPlA.pMiPpLeExA.ScEom> wrote:

X x;
const std::string& r = x.s(); // affected by subsequent x destruction
std::string s = x.s(); // not affected by subsequent x destruction

Whoa, stop, that's wrong! r is __not__ affected by x destruction,
because x gets destroyed __after__ r (sort to speak). Try thinking
like this, instead (that's what standard requires WRT variable
construction-destruction):

{ // x only available in this block
X x;
  { // r only available in this block
   const std::string& r = x.s();
   { // s only available in this block
    std::string s = x.s();
   }
  }
}

As you can see, it's not possible for r to be bad due to destroyed x.
What __is__ possible (and people make that mistake), is that you
somehow copy the reference somehow (to a pointer) and keep that after
x is destroyed, e.g.

const std::string* p;
{
X x;
const std::string& r = x.s(); // affected by subsequent x
destruction
p = &x; // Whoops!
std::string s = x.s(); // not affected by subsequent x destruction
}
p == "Undefined behavior";

Goran.

It wasn't supposed to be a literal (or complete) example. Here's a
better one:

#include <iostream>
#include <string>

#include <boost/shared_ptr.hpp>
using boost::shared_ptr;

struct X
{
    std::string m_s;

    X() : m_s("Wibble") {}

    const std::string& s() const
    {
        return m_s;
    }
};

int main()
{
    shared_ptr<X> x(new X);
    const std::string& r = x->s();
    x.reset();

    // BOOM
    std::cout << r << '\n';

    return 0;
}

Regards,
Stu

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