Re: Mutability of temporary variables
On 20/11/2011 02:34, Paul <pchrist wrote:
"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?
No; a string literal is an rvalue. The function
what_does_gplusplus_call_me can only accept an lvalue as an argument
(hence the std::cout statement) as a non-const lvalue reference will not
bind to an rvalue hence the explanatory compiler error below.
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.
It is an rvalue; the confusion is yours due to your inability to read
posts properly.
}
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 :) )
Again you appear unable to accept the fact that the same term can have a
different and/or enhanced meaning from one domain to the next. C++ is
not Computer Science; Computer Science is not C++.
foo() = foo(); // even though foo() is an rvalue I can still assign to
it as foo is of class type; so in C++ saying an rvalue as something
always on the "right hand side of an assignment" is erroneous.
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.
lvalues and rvalues are not "mumbo jumbo"; understanding them is key to
using C++ (especially C++11) properly.
HTH.
/Leigh