Re: Mutability of temporary variables
"Leigh Johnston" <leigh@i42.co.uk> wrote in message
news: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";
Are you suggesting a string literal is an l-value?
Seems like a load of confusion to me , its a string literal why not call it
a string literal instead of trying to say its an l-value or an m-value or
whatever.
}
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.
Basically an l-value is something on the left hand side of an assignment and
an r-value is on the right hand side. Its simple and no need to get involved
in any more complex interpretations of thiis l-value , r-value nonsense
unless you are creating a compiler or something?
Its just the usual arguments revolving around the interpretation of the holy
standard, sorry I mean standardS( for the sake of Ian :) )
I do support you on this and hope you are right because I'd like to see you
correcting that victor guy as he's a bit annoying as all his discussions are
one way. GL, Im not interested in all that l-value , r-value mumbo jumbo
just thought I'd highlight the fact that you corrected victors error,
presuming you are correct. Nobody else responded.
--- Posted via news://freenews.netfront.net/ - Complaints to news@netfront.net ---