Can you use conversion over typecasting?

Answer 1

Yes. A type cast generally means that an object's representation is re-interpreted, however re-interpretation isn't always suitable so we must use conversion instead.

The most common use of type-casting is to re-interpret pointer variables. A pointer variables stores a memory address and its type determines how the object stored at that address is to be interpreted. However a pointer to void has no type, it can refer to an object of any type. But if we want to access that object through the pointer we must first cast the pointer to the appropriate type. This requires no conversion because the memory address stored in the pointer does not change, we're only changing how that address is interpreted.

Another use of type casts is when we have a word (multi-byte value) and we wish to access the individual bytes in the word. For this we can simply cast the type to an array of char. Again, this requires no conversion whatsoever because the representation remains the same, only its interpretation changes.

When the physical representation must change, we must use a type conversion rather than a type cast. For instance, if we wish to re-interpret a char variable as a word then we must create a new variable to store that new representation. In mixed-mode arithmetic we can use any combination of numeric types (such as int, float and double) but with complex expressions it can often be difficult to see what conversions are actually taking place. For example:

void f (int i, float f, double d) {

int x = i * f * d;

}

In the above example, the expression is evaluated as follows:

void f (int i, float f, double d) { double t1 = (double) f; // conversion from float to double

double t2 = t1 * d; // no conversion

double t3 = (double) i; // conversion from int to double

double t4 = t3 * t2; // no conversion

int x = (int) t4; // conversion from double to int

}

Had i, f and d been of the same type as x, then the expression x = i * f * d would have resulted in just one temporary variable holding the evaluation of f * d, and no conversions would be necessary. But as soon as we introduce conversions the number of temporary variables increases accordingly.

In some cases we may wish to control the conversions rather than rely on automatic conversion which always promotes types to the highest precision type required of the expression. For instance, if we were not interested in the fractional components of the float and double types, we can explicitly cast them:

void f (int i, float f, double d) {

int x = i * (int) f * (int) d;

}

In so doing we reduce the number of conversions and temporaries we require:

void f (int i, float f, double d) {

int t1 = (int) f; // conversion from float to int

int t2 = (int) d; // conversion from double to int

int t3 = f * d; // no conversion

int x = i * t3; // no conversion

}