Hi all,
I have this program.
Now my doubt is what is the advantage of type casting 0x12 to int. suppose if the test_variable data type is "char" then should i type cast to "char"?Code:int test_variable; int main() { test_variable = (int)0x12; }
Thanks and regards,
Satya
No advantage in this case since the type of 0x12 is already int.
Look up a C++ Reference and learn How To Ask Questions The Smart WayOriginally Posted by Bjarne Stroustrup (2000-10-14)
Thank you for the reply. Can you please tell me in which cases i have to use type casts specially for constants.
For constants, I would try to use a constant of an appropriate type, e.g., to use a u suffix when I want an unsigned integer constant, or an f suffix if I want a float rather than a double.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Some functions, like fgetc, getchar, use type casting to compare the value being returned with EOF. Which is why you normally store the return value in type int. If you instead store them in type char, the comparison with EOF will never succeed.
There are probably better examples, but generally you type cast for comparisons and other things that wouldn't work otherwise. Take this compare function, part of a bubble sort program than does multiple data types:
The void values being passed in are cast in the assignment so that the proper long values can be compared.Code:int compare_long(const void *m, const void *n) { long *ml, *nl; ml=(long *)m; nl=(long *)n; return (*ml>*nl); }
Last edited by Alpo; 05-08-2014 at 12:15 PM. Reason: made mistake
void* can be converted, without a cast, to any object pointer type. In fact, the casts used here hide a potential problem:The void values being passed in are cast in the assignment so that the proper long values can be compared.
yields, with one compiler: “warning #2332: a value of type "const void *" cannot be assigned to an entity of type "long *" (dropping qualifiers)”Code:const void *m; long *ml; ml = m;
A diagnostic of some sort is required with the above code.
The casts hide the fact that const was removed. Instead:
yields no diagnostic (or at least is not required to).Code:const void *m; const long *ml; ml = m;
In general, my advice for casting is this: don't do it. Whenever I see a cast I get suspicious, because typically there's a better way to handle the problem. A few places where casting is probably the right choice:
- When you have two integer variables but need to do floating point division with them (if a constant is used as the divisor or dividend, it's better to just use a double such as 100.0 instead of an integer 100).
- If you're passing something to a function with a variable argument list, and the promoted type isn't guaranteed to match what is expected. For example, casting a pointer to void* when using %p in printf().
- If you're using one of the ctype functions such as isalpha(), and passing a char to it, the char should be cast to unsigned char. This is due to (what I consider) a poor design in ctype functions, which was likely inherited from pre-standard implementations.
@Cas - Thanks, I'll update that on file.
Plus when using const this always gets added to my confusion:
int *const p1 = q; // constant pointer to int variable
int const* p2 = q; // pointer to constant int
const int* p3 = q; // pointer to constant int
from - Stroustrup: C++ Style and Technique FAQ
