Re: Understanding temporary objects / taking address

From:

Ian Collins <ian-news@hotmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 29 Jun 2006 16:26:56 +1200

Message-ID:

<4gh34gF1n4ppnU4@individual.net>

mangesh wrote:

Please don't top post and use gibberish such as 'u'.

Frederick Gotham wrote:

template<class T>
const T *AdrsTmp( const T &temp ) { return &temp; }

int main()
{
Func( AdrsTmp( ArbitraryClass() ) );
}

A temporary lives on until the end of the statement; so the temporary in
the above code gets killed at the end of the semi-colon in "main".

I wonder what people would think if I rewrote "AdrsTmp" like as follows:

template<class T>
T *AdrsTmp( const T &temp ) { return const_cast<T*>(&temp); }

We know that it's pefectly okay to cast away constness if the object in
question is in fact non-const. The temporary in "main" is non-const --
that's for sure. However... is the "AdrsTmp" function free to create
another temporary when it takes its argument, rather than work with the
temporary provided by main... ?

Hi ,
u have writtten " The temporary in "main" is non-const -- that's for
sure. "
Is constantness of temporary object compiler dependent ? Because
somewhere on
net i remember reading that temporary object created by compiler are
constant , but i can't recall name of compiler .

No, the temporary is an rvalue. It can be assigned to a const
reference, but as a value, you can take it's address. All the wrapper
does is assign it to a const reference and take the address of the
reference.

A bit like:

const int& i = 42;

const int* p = &i;

42 is an rvalue, so you can assign it to a const reference, but you
couldn't take its address.

--
Ian Collins.