Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > "lifetime of temporary bound to reference..."

Reply
Thread Tools

"lifetime of temporary bound to reference..."

 
 
Igor R.
Guest
Posts: n/a
 
      01-26-2009
Hello,

Does the rule in the subj applies to the following:

std:air<int, int> getPair()
{
return std:air<int, int>(1, 2);
}

int main()
{
// is this legal?
const std:air<int, int> &p1 = getPair();
// and this?
std:air<int, int> &p2 = getPair();
std::cout << p1.first << p2.second;
}
 
Reply With Quote
 
 
 
 
James Kanze
Guest
Posts: n/a
 
      01-27-2009
On Jan 26, 7:25 pm, Victor Bazarov <(E-Mail Removed)> wrote:
> Igor R. wrote:
> > Does the rule in the subj applies to the following:


First, very importantly, the rule in the subject doesn't exist.
Whether a temporary is bound to a reference has no effect on its
lifetime. The only time the lifetime of a temporary is extended
is if a reference is initialized with a rvalue. (The
difference, of course, is whether a temporary is bound to a
reference is a transitive relationship; whether a temporary was
initialized with an rvalue isn't.)

> > std:air<int, int> getPair()
> > {
> > return std:air<int, int>(1, 2);
> > }


> > int main()
> > {
> > // is this legal?
> > const std:air<int, int> &p1 = getPair();


> Yes, this is legal. The temporary returned by 'getPair' will
> have the same lifetime as the 'p1' reference (i.e. until
> 'main' returns).


Formally, it might be a copy of the temporary (which is also a
temporary) which has its lifetime extended (but I think this
possibility will be removed from C++0x).

> > // and this?
> > std:air<int, int> &p2 = getPair();


> No, this is not legal. A temporary can only be bound to a
> reference to const.


No! A reference can only be initialized with an rvalue if it is
const and non volatile. But it's quite possible to arrange for
a temporary to bind to a non-const reference (const_cast, member
functions, etc.).

This point is in some ways related to my initial comment, above:
in order to bind a temporary to a non-const reference, you must
somehow arrange for the expression to be an lvalue. And since
the initialization expression of the temporary is not an rvalue,
the lifetime of the temporary will NOT be extended.

This is probably best explained with a simple example:

struct S
{
S& me() { return *this ; }
} ;

S& rs = S().me() ;

The reference rs is clearly bound to a temporary, even though
the reference is non-const. On the other hand, the reference
was not initialized with an rvalue expression, so the lifetime
of the temporary will NOT be extended beyond the end of the full
expression. (Technically, the temporary object S() will be
destructed before the reference rs is initialized. In practice,
there's no way a conforming program can tell, however.)

--
James Kanze (GABI Software) email:(E-Mail Removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
 
Reply With Quote
 
 
 
 
James Kanze
Guest
Posts: n/a
 
      01-28-2009
On Jan 27, 2:49 pm, Victor Bazarov <(E-Mail Removed)> wrote:
> James Kanze wrote:
> > On Jan 26, 7:25 pm, Victor Bazarov <(E-Mail Removed)> wrote:
> >> Igor R. wrote:
> >>> Does the rule in the subj applies to the following:


> > First, very importantly, the rule in the subject doesn't
> > exist. Whether a temporary is bound to a reference has no
> > effect on its lifetime. The only time the lifetime of a
> > temporary is extended is if a reference is initialized with
> > a rvalue. (The difference, of course, is whether a
> > temporary is bound to a reference is a transitive
> > relationship; whether a temporary was initialized with an
> > rvalue isn't.)


> I believe you're attempting to split hairs. Please see the
> second sentence of 12.2/5. "The temporary to which the
> reference is bound ... persists for the lifetime of the
> reference". If that's not "lifetime of temporary bound to
> reference", what exactly is it?


That's an interesting quote, because of course, it's neither
implementable, nor implemented.

My point wasn't meant to split hairs. It was to point out a
very important distinction: the fact that the extension of
lifetime is not transitive. The lifetime is only extended to
match that of the reference which was initialized with the
expression generating the temporary. The fact that some
reference is bound to a temporary doesn't guarantee that that
temporary will not be destroyed while the reference is still
usable.

--
James Kanze (GABI Software) email:(E-Mail Removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Lower bound & Upper bound sunil panda Java 9 10-07-2008 08:32 PM
Passing Bound Object value to another Bound Object Phillip Vong ASP .Net 0 07-27-2006 10:54 PM
How to represent the data in a not bound control via bound control Mario Krsnic ASP .Net 0 06-23-2006 07:38 AM
Getting lower-bound and upper-bound of strings input Rhiner Dan C++ 1 03-27-2005 02:03 AM
A reference to non-const to be bound to a temporary object John Ky C++ 9 02-23-2004 12:53 AM



Advertisments