For example, if you do this:

cout < < 5 - 10u;

You get 4294967291.

If you do this:

int x= 5u - 10;
cout < < x;

You get -5.

So what’s the difference? The answer has to do with the way types are promoted. When the compiler encounters 5 - 10u, it promotes 5 to an unsigned value, and 5u - 10u produces the result 4294967291 (unsigned). However, it’s worth noting that 4294967291u and -5 have the exact same bit pattern — the interpretation depends entirely on whether the value is treated as signed or unsigned.

Because 5 - 10u produces an unsigned value, cout treats it as an unsigned value, and prints 4294967291 as the result.

However, in your case, you’ve assigned this unsigned value back to a signed integer. Because x is signed, when you print x in the next statement, cout prints the value as if it were signed, which is why it prints -5.

So the ultimate answer is that the statement as written is true. You’ve simply cast 4294967291 unsigned back to a signed integer and printed that value, which is the value you were intuitively expecting anyway. :) ]]> http://www.learncpp.com/cpp-tutorial/44-type-conversion-and-casting/#comment-6830 Allen01 Tue, 29 Jan 2008 21:05:40 +0000 http://www.learncpp.com/cpp-tutorial/44-type-conversion-and-casting/#comment-6830 When I build and compile the code below, the output is -5. You mention that: "This hierarchy can cause some interesting issues. For example, you might expect the expression 5u - 10 to evalute to -5 (5u means 5 as an unsigned integer). But in this case, the signed integer (10) is promoted to an unsigned integer, and the result of this expression is the unsigned integer 4294967291!" Is the hierarchy issue compiler specific? I am using VC 2005 Express. <PRE> #include "stdafx.h" #include <iostream> int main() { using namespace std; int x; x = 5u - 10; cout << x; return 0; } </PRE> When I build and compile the code below, the output is -5. You mention that:

“This hierarchy can cause some interesting issues. For example, you might expect the expression 5u - 10 to evalute to -5 (5u means 5 as an unsigned integer). But in this case, the signed integer (10) is promoted to an unsigned integer, and the result of this expression is the unsigned integer 4294967291!”

Is the hierarchy issue compiler specific? I am using VC 2005 Express.

#include “stdafx.h”
#include 

int main()
{
using namespace std;
int x;
x = 5u - 10;
cout < < x;
return 0;
}

The problem with C-style casting is that it may use a static_cast, reinterpret_cast, or const_cast (or a combination thereof) depending on the situation, and we’re not always sure which one(s) it’s going to pick. That’s why using static_cast is safer — we’re always sure what it’s going to do, and if we try to do something it wasn’t meant for, it will give us a warning.

Here’s an example of a C-style cast:

const char *strMsg="Can't touch this!";
unsigned char *ptr=(unsigned char*)strMsg;

Not only is this casting a char to an unsigned char, it’s also tossing away the const. I think it’s doing a reinterpret_cast and a const_cast combination. In any case, you can see that this is dangerous. Let’s try using a C++ style static_cast instead:

const char *strMsg="Can't touch this!";
unsigned char *ptr=static_cast(strMsg);

When we try to compile this, the compiler will complain:

C:\Test.cpp(46) : error C2440: 'static_cast' : cannot convert from 'const char *' to 'unsigned char *'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

In other words, the C++ style casts give you more control over what type of casting you want to perform, and will warn you if you do something that violates the constraints on the cast. On the other hand, C-style casts will try to convert whatever you throw at it, regardless of whether it really makes sense to be doing so. This is dangerous and can lead to unexpected behavior.

“The C style cast can be inherently misused, because it will let you do things that may not make sense, such as getting rid of a const or changing a data type without changing the underlying representation. C introduces a new casting operator called static_cast. A static cast works similarly to the C style cast, except it will only do standard type conversions, which reduces the potential for inadvertant misuse”
================================================
I didn’t get the difference b/w Cpp style cast,C style cast and static_cast…………I think all of them do the same thing…only the syntax is different.????
================================================