Type conversion

In computer science, type conversion, type casting, type coercion, and type juggling are different ways of changing an expression from one data type to another. An example would be the conversion of an integer value into a floating point value or its textual representation as a string, and vice versa. Type conversions can take advantage of certain features of type hierarchies or data representations. Two important aspects of a type conversion are whether it happens "implicitly" (automatically) or "explicitly", and whether the underlying data representation is converted from one representation into another, or a given representation is merely "reinterpreted" as the representation of another data type. In general, both primitive and compound data types can be converted.
Each programming language has its own rules on how types can be converted. Languages with strong typing typically do little implicit conversion and discourage the reinterpretation of representations, while languages with weak typing perform many implicit conversions between data types. Weak typing language often allow forcing the compiler to arbitrarily interpret a data item as having different representations—this can be a non-obvious programming error, or a technical method to directly deal with underlying hardware.
In most languages, the word "coercion" is used to denote an "implicit" conversion, either during compilation or during run time. For example, in an expression mixing integer and floating point numbers (like 5 + 0.1), the compiler will automatically convert integer representation into floating point representation so fractions are not lost. Explicit type conversions are either indicated by writing additional code (e.g. adding type identifiers or calling built-in routines) or by coding conversion routines for the compiler to use when it otherwise would halt with a type mismatch.
In most ALGOL-like languages, such as Pascal, Modula-2, Ada and Delphi, "conversion" and "casting" are distinctly different concepts. In these languages, "conversion" refers to either implicitly or explicitly changing a value from one data type storage format to another, e.g. a 16-bit integer to a 32-bit integer. The storage needs may change as a result of the conversion, including a possible loss of precision or truncation. The word "cast", on the other hand, refers to explicitly changing the "interpretation" of the "bit pattern" representing a value from one type to another. For example, 32 contiguous bits may be treated as an array of 32 booleans, a 4-byte string, an unsigned 32-bit integer or an IEEE single precision floating point value. Because the stored bits are never changed, the programmer must know low level details such as representation format, byte order, and alignment needs, to meaningfully cast.
In the C family of languages and ALGOL 68, the word "cast" typically refers to an "explicit" type conversion (as opposed to an implicit conversion), causing some ambiguity about whether this is a re-interpretation of a bit-pattern or a real data representation conversion. More important is the multitude of ways and rules that apply to what data type (or class) is located by a pointer and how a pointer may be adjusted by the compiler in cases like object (class) inheritance.
Language comparison.
C-like languages.
Implicit type conversion.
Implicit type conversion, also known as "coercion", is an automatic type conversion by the compiler. Some programming languages allow compilers to provide coercion; others require it.
In a mixed-type expression, data of one or more subtypes can be converted to a supertype as needed at runtime so that the program will run correctly. For example, the following is legal C language code:
double d;
long l;
int i;
if (d > i) d = i;
if (i > l) l = i;
if (d == l) d *= 2;
Although , , and belong to different data types, they will be automatically converted to equal data types each time a comparison or assignment is executed. This behavior should be used with caution, as unintended consequences can arise. Data can be lost when converting representations from floating-point to integer, as the fractional components of the floating-point values will be truncated (rounded toward zero). Conversely, precision can be lost when converting representations from integer to floating-point, since a floating-point type may be unable to exactly represent an integer type. For example, might be an IEEE 754 single precision type, which cannot represent the integer 16777217 exactly, while a 32-bit integer type can. This can lead to unintuitive behavior, as demonstrated by the following code:
int main(void)
 int i_value = 16777217;
 float f_value = 16777216.0;
 printf("The integer is: %d\n", i_value);
 printf("The float is: %f\n", f_value);
 printf("Their equality: %d\n", i_value == f_value);
On compilers that implement floats as IEEE single precision, and ints as at least 32 bits, this code will give this peculiar print-out:
 The integer is: 16777217
 The float is: 16777216.000000
 Their equality: 1
Note that 1 represents equality in the last line above. This odd behavior is caused by an implicit conversion of to float when it is compared with . The conversion causes loss of precision, which makes the values equal before the comparison.
Important takeaways:
Type promotion.
One special case of implicit type conversion is type promotion, where the compiler automatically expands the binary representation of objects of integer or floating-point types. Promotions are commonly used with types smaller than the native type of the target platform's arithmetic logic unit (ALU), before arithmetic and logical operations, to make such operations possible, or more efficient if the ALU can work with more than one type. C and C++ perform such promotion for objects of boolean, character, wide character, enumeration, and short integer types which are promoted to int, and for objects of type float, which are promoted to double. Unlike some other type conversions, promotions never lose precision or modify the value stored in the object.
In Java:
int x = 3;
double y = 3.5;
System.out.println(x + y); // The output will be 6.5
Explicit type conversion.
Explicit type conversion is a type conversion which is explicitly defined within a program (instead of being done by a compiler for implicit type conversion). It is defined by the user in the program.
double da = 3.3;
double db = 3.3;
double dc = 3.4;
int result = (int)da + (int)db + (int)dc; // result == 9
// if implicit conversion would be used (as with "result = da + db + dc"), result would be equal to 10
There are several kinds of explicit conversion.
In object-oriented programming languages, objects can also be downcast : a reference of a base class is cast to one of its derived classes.
C# and C++.
In C#, type conversion can be made in a safe or unsafe (i.e., C-like) manner, the former called "checked type cast".
Animal animal = new Cat();
Bulldog b = (Bulldog) animal; // if (animal is Bulldog), stat.type(animal) is Bulldog, else an exception
b = animal as Bulldog; // if (animal is Bulldog), b = (Bulldog) animal, else b = null
animal = null;
b = animal as Bulldog; // b == null
In C++ a similar effect can be achieved using "C++-style cast syntax".
Animal* animal = new Cat;
Bulldog* b = static_cast<Bulldog*>(animal); // compiles only if either Animal or Bulldog is derived from the other (or same)
b = dynamic_cast<Bulldog*>(animal); // if (animal is Bulldog), b = (Bulldog*) animal, else b = nullptr
Bulldog& br = static_cast<Bulldog&>(*animal); // same as above, but an exception will be thrown if a nullptr was to be returned
 // this is not seen in code where exception handling is avoided
animal = nullptr;
b = dynamic_cast<Bulldog*>(animal); // b == nullptr
delete animal; // always free resources
Eiffel.
In Eiffel the notion of type conversion is integrated into the rules of the type system. The Assignment Rule says that an assignment, such as:
x := y
is valid if and only if the type of its source expression, codice_1 in this case, is "compatible with" the type of its target entity, codice_2 in this case. In this rule, "compatible with" means that the type of the source expression either "conforms to" or "converts to" that of the target. Conformance of types is defined by the familiar rules for polymorphism in object-oriented programming. For example, in the assignment above, the type of codice_1 conforms to the type of codice_2 if the class upon which codice_1 is based is a descendant of that upon which codice_2 is based.
Definition of type conversion in Eiffel.
The actions of type conversion in Eiffel, specifically "converts to" and "converts from" are defined as:
A type based on a class CU "converts to" a type T based on a class CT (and T "converts from" U) if either
Example.
Eiffel is a fully compliant language for Microsoft .NET Framework. Before development of .NET, Eiffel already had extensive class libraries. Using the .NET type libraries, particularly with commonly used types such as strings, poses a conversion problem. Existing Eiffel software uses the string classes (such as codice_7) from the Eiffel libraries, but Eiffel software written for .NET must use the .NET string class (codice_8) in many cases, for example when calling .NET methods which expect items of the .NET type to be passed as arguments. So, the conversion of these types back and forth needs to be as seamless as possible.
 my_string: STRING_8 -- Native Eiffel string
 my_system_string: SYSTEM_STRING -- Native .NET string
 my_string := my_system_string
In the code above, two strings are declared, one of each different type (codice_9 is the Eiffel compliant alias for System.String). Because codice_8 does not conform to codice_7, then the assignment above is valid only if codice_8 converts to codice_7.
The Eiffel class codice_7 has a conversion procedure codice_15 for objects of type codice_8. Conversion procedures are also always designated as creation procedures (similar to constructors). The following is an excerpt from the codice_7 class:
 class STRING_8
 create
 make_from_cil
 convert
 make_from_cil ({SYSTEM_STRING})
The presence of the conversion procedure makes the assignment:
 my_string := my_system_string
semantically equivalent to:
 create my_string.make_from_cil (my_system_string)
in which codice_18 is constructed as a new object of type codice_7 with content equivalent to that of codice_20.
To handle an assignment with original source and target reversed:
 my_system_string := my_string
the class codice_7 also contains a conversion query codice_22 which will produce a codice_8 from an instance of codice_7.
 class STRING_8
 create
 make_from_cil
 convert
 make_from_cil ({SYSTEM_STRING})
The assignment:
 my_system_string := my_string
then, becomes equivalent to:
 my_system_string := my_string.to_cil
In Eiffel, the setup for type conversion is included in the class code, but then appears to happen as automatically as explicit type conversion in client code. The includes not just assignments but other types of attachments as well, such as argument (parameter) substitution.
Rust.
Rust provides no implicit type conversion (coercion) between primitive types. But, explicit type conversion (casting) can be performed using the codice_25 keyword.
println!("1000 as a u16 is: {}", 1000 as u16);
Security issues.
In hacking, typecasting is the misuse of type conversion to temporarily change a variable's data type from how it was originally defined. This provides opportunities for hackers since in type conversion after a variable is "typecast" to become a different data type, the compiler will treat that hacked variable as the new data type for that specific operation.