Re: Shooting yourself in the foot with rvalue references
void f( int&& rri )
{
g( rri );
}
void g( int& ri )
{
ri = 4;
}
int main()
{
int&& rri = 5;
rri = 4;
f( 5 );
return 0;
}
According to C++0x, an rvalue reference that has a name is an lvalue. So
in
my example, the first line of code in main() aims at your foot and the
second line bluntly pulls the trigger. The call to f() is a shot around
the
corner, which is more practical, but the bullet goes through the same
whole
in your foot.
Hi, pardon my ignorance, but I cannot find anything in this example
that could be called "shooting oneself in the foot". Could you, or
someone, provide an explanation about why this code is harmful? I read
it as follows.
In first line of main you create a temporary with value 5 and with the
use of reference you extend its life time to the end of function main.
In the second line, you change the value of that temporary to 4. In
the third line of main you do a similar thing to a second temporary,
whose value you change to 4 and it is discarded at the end of third
line.
"Shooting yourself in the foot" could mean either crashing the
application, or doing something contrary to what the user expected. I
cannot assign either meaning to the above code.
Could someone help me understand?
Regards,
&rzej
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]