Re: lifetime of objects (here: strings)
On Apr 11, 5:19 pm, r...@zedat.fu-berlin.de (Stefan Ram) wrote:
James Kanze <james.ka...@gmail.com> writes:
Exact. But the effect is not transitive; the lifetime is
only extended to match the reference initialized with the
temporary, not to other references which were initialized
from that reference.
string const & my_string3( my_string1 + my_string2 );
I am trying to construct an example where this
intransitivity can be seen.
std::string const f( std::string const& arg )
{
return arg ;
}
void
g()
{
std::string const& s( f( std::string( "temp" ) ) ) ;
// ...
}
One might try to create a dangling reference by =BBreturn d;=AB
in =BB::std::string const & f(){ /* code from above */ return
d; }=AB. This will indeed succeed (to create a dangling
reference). So is this the situation, where the
intransitivity can be observed?
Two cases, really. (Maybe more, but two occur off hand.) As
above, using the temporary to initialize a reference to a
function which returns it, and using the reference in the
initialization of a dynamically allocated object.
But the following also seems to return a dangling reference,
while the result is the first const reference the temporary
is bound to.
::std::string const & f(){ return "a"; }
Yes. But this is more or less the classical "don't return a
reference or a pointer to a local variable or temporary. There
are two absolute limits to the lifetime of a temporary: the full
expression it is created in is the lower limit (unless one
considers function parameters temporaries), and the scope in
which the temporary is created is the upper one---all rules
extending the lifetime take second rang to this one.
A good example of this second rule coming into play:
class C { C() ; std::string const& rs ; } ;
C::C()
: rs( "abc" )
{
}
Clearly, rs is initialized with a temporary. Directly, so the
lifetime should be extended. Which it is, but only until the
end of the constructor. (The reason for this is simple: where
does the compiler put the temporary if its lifetime is to
outlive the call to the constructor?)
Finally: I would like to one again stress that std::string is a
value type. You should use it exactly like you would int or
double, at least with regards to whether to use a reference or
not. You don't generally have local variables or members which
are references to int or double, and you shouldn't generally
have local variables or members which are references to string.
(There are exceptions, of course, but these generally involve
references to objects which outlive the function.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34