cesar tejeda wrote:
Historically (some twenty years ago), C++ did allow binding a
temporary to a non-const reference (and many compilers still
allow it today, as a non-conformant extension). It was found,
however, to be somewhat error prone, in cases like e.g.:
void
incr( int& i )
{
++ i ; // Obviously something more complex in real
// code.
}
void
f()
{
unsigned x = 0 ;
incr( x ) ;
}
In this case, the temporary is the result of an implicit
conversion, and the author is very surprised that the call to
incr doesn't modify x.
So I infer that for making a unsigned to int conversion, C++
creates a new temporary variable and copies the bits
C++ creates a new variable. Whether it just copies the bits or
not is implementation defined---all that is guaranteed is that
if the original type contained a value that is representable in
the target type, the target type will have that value. (Since
it is also guaranteed that signed integers use the same
representation as unsigned integers for non-negative values,
this means that you can count on getting the same bits for
values which fit.)
instead of the classical C
behaviour that is doing nothing and understanding the bits of x as bits
representing integers.
There is no difference between C and C++ here. The result of a
conversion is an rvalue, i.e. a temporary. Any apparent
difference is due to the fact that you generally cannot tell in
C; you can't take the address of the rvalue, and of course, you
can't bind it to a reference.
You are right. That?s the reason why expressions like:
doesn?t compile complaining about invalid l-values. That surprised me
[ comp.lang.c++.moderated. First time posters: Do this! ]