Re: Shooting yourself in the foot with rvalue references

Hello everybody!

Just yesterday I started to make myself familiar with the C++0x feature of
rvalue references. As a side note, I would like to say that I consider the
following articles to be very good introductions:

http://thbecker.net/articles/rvalue_references/section_01.htmlhttp://www.aristeia.com/TalkNotes/ACCU2011_MoveSemantics.pdf

However, even after having read all of the first and at least some of the
second article as well as a considerable number of explanations about rvalue
references on various web sites, one question still remains open. Please
take a look at the following code:

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.

I have been desperately looking for a rule that says that C++0x does not
have such a severe security whole, but I haven't found one yet. Or is this
only in compliance with the first amendment to the C++ standard, which says
that "the committee shall make no rule that prevents C++ programmers from
shooting themselves in the foot"?