You can use type casts to explicitly convert types.
cast-expression :
unary expression
( type-name ) cast-expression
type-name :
specifier-qualifier-list abstract-declarator opt
The type-name is a type and operand is a value to be converted to that type. An expression with a type cast is not an l-value. The operand is converted as though it had been assigned to a variable of type type-name. The conversion rules for assignments (outlined in “Assignment Conversions”) apply to type casts as well.
Any identifier may be cast to void type. However, if the type specified in a type-cast expression is not void, then the identifier being cast to that type cannot be a void expression. Any expression can be cast to void, but an expression of type void cannot be cast to any other type. For example, a function with void return type cannot have its return cast to another type.
Note that a void * expression has a type pointer to void, not type void. If an object is cast to void type, the resulting expression cannot be assigned to any item. Similarly, a type-cast object is not an acceptable l-value, so no assignment can be made to a type-cast object.
Microsoft Specific
A type cast can be an l-value expression as long as the size of the identifier does not change. See topic for information on l-value expressions.¨You can convert an expression to type void with a cast, but the resulting expression can be used only where a value is not required. An object pointer converted to void * and back to the original type will return to its original value.
Table 4.5 shows the types that can be cast to any given type.
Table 4.5 Legal Type Casts
| Destination Types | Potential Sources |
| Integral types | Any integer type or floating-point type, or pointer to an object |
| Floating-point | Any arithmetic type |
| A pointer to an object, or (void *) | Any integer type, (void *), a pointer to an object, or a function pointer |
| Function pointer | Any integral type, a pointer to an object, or a function pointer |
| A structure, union, or array | None |
| Void type | Any type |
Microsoft Specific
When a longinteger is cast to a short, or a shortis cast to a char(demotion), the least-significant bytes are retained.For example, this statement
short x = (short)x12345678L;
assigns the value 0x5678 to x, and this statement
char y = (char)0x1234;
assigns the value 0x34 to y.
On a 16-bit computer, near pointers are the same size as short integers; casting near pointers to short (or short to near pointers) has no effect on the value. Far pointers and huge pointers are the same size as long integers. Casting far or huge pointers to long (or long to far or huge pointers) has no effect on the value.
When a near pointer on a 16-bit computer is cast to long, the 16-bit value is “normalized,” which means the segment (usually DS) and offset are combined to produce a 32-bit memory location. When a far or huge pointer is cast to short, the value is truncated to a short.
The compiler normalizes based pointers when necessary, unless the based pointer is a constant zero, in which case it is assumed to be a null pointer. See topic for more information on based pointers.
When an integral number is cast to a floating-point value that cannot exactly represent the value, the value is rounded (up or down) to the nearest suitable value.
For example, casting an unsigned long (with 32 bits of precision) to a float (whose mantissa has 23 bits of precision) rounds the number to the nearest multiple of 256. The long values in the range of 4,294,966,913 to 4,294,967,167 are all rounded to the float value 4,294,967,040.¨