Re: Mutability of temporary variables

From:

Leigh Johnston <leigh@i42.co.uk>

Newsgroups:

comp.lang.c++

Date:

Sun, 20 Nov 2011 01:14:53 +0000

Message-ID:

<S8qdnejZWYEMyVXTnZ2dnUVZ8hadnZ2d@giganews.com>

On 20/11/2011 00:45, Leigh Johnston wrote:

On 20/11/2011 00:14, Paul <pchrist wrote:

"Leigh Johnston"<leigh@i42.co.uk> wrote in message
news:Do2dnVH-ff_DIVrTnZ2dnUVZ8qOdnZ2d@giganews.com...

On 19/11/2011 13:45, Victor Bazarov wrote:

On 11/19/2011 8:18 AM, Paavo Helde wrote:

kyle<kyle@nomail.com> wrote in
news:op.v4605gilpbcp0d@localhost.localdomain:

Consider following code:

int main() {
const int& c = int();
int& m = const_cast<int&>(c);
m = 4;
}

The object of the snippet is to get a mutable reference to a
temporary. This cant be done directly because non-const reference
cannot bind to temporary, but we should be OK with casting away
constness of reference 'c' since it doesn't actually refer to const
object.

Temporaries are mutable, so in whole my snippet is legal C++. Am i
correct?

Yes, I think you are correct. Another trick to get a mutable reference
to
a temporary is to use a non-const member function. This avoids
const_cast, but of course lifetime extending by binding to a const
reference does not work any more:

struct A {
int m;
A& Ref() {return *this;}
};

void f(A& a) {
a.m = 4;
}

int main() {
f( A().Ref() );
}

There is a difference between your example and the OP's. In your
example
the temporary is of a class type, and the expression A() produces an
lvalue to begin with.

No; A() produces an rvalue.

Um no , the value produced is neither an l-value or an r-value , its
inbetween and its known as an intermediate-value.
Its value is neither left nor right because its not actually a value
at all.
Its an abstractatin of the representented data, which was never actually
data in the first place because it was just an identifier which
"pointed to"
the data or "represnted" said data or datas.
But the identifier was not even an identifier because it was a "name"
which
represents an identifier which , in turn , represents data.

Get a grip noob.

#include <iostream>

struct foo
{
};

void what_am_i(const foo&)
{
std::cout << "I seem to be an lvalue\n";
}

void what_am_i(const foo&&)
{
std::cout << "I seem to be an rvalue\n";
}

int main()
{
foo f;
what_am_i(f);
what_am_i(foo());
}

Outputs:

I seem to be an lvalue
I seem to be an rvalue

Go figure, "noob".

Or to put it another way:

#include <iostream>

struct foo
{
};

void what_does_gplusplus_call_me(foo&)
{
std::cout << "I seem to be an lvalue\n";
}

int main()
{
what_does_gplusplus_call_me(foo());
}

Outputs:

test.cpp:14:36: error: invalid initialization of non-const reference of
type 'foo&' from an rvalue of type 'foo'

If the g++ compiler writers are happy calling "foo()" an *rvalue* than
so am I.

/Leigh