Editing Type conversion

{{Short description|Changing an expression from one data type to another}}
{{for|the aviation licensing process|Type conversion (aviation)}}
{{redirect|Upcasting|metal casting|Casting (metalworking)#Upcasting}}
{{multiple issues|
{{More citations needed|date=May 2011}}
{{original research|date=May 2018}}
}}
{{Use dmy dates|date=August 2021}}

In [[computer science]], '''type conversion''',<ref name=":0">{{Cite book|title=S. Chand's Computer Science|year=2008|isbn=978-8121929844|pages=81–83|last1=Mehrotra|first1=Dheeraj|publisher=S. Chand }}</ref><ref>{{Cite book|title=Programming Languages - Design and Constructs|year=2013|isbn=978-9381159415|pages=35|publisher=Laxmi Publications }}</ref> '''type casting''',<ref name=":0" /><ref name=":1">{{Cite book|title=Concise Encyclopedia of Computer Science|last=Reilly|first=Edwin|year=2004|isbn=0470090952|pages=[https://archive.org/details/conciseencyclope0000unse_v5u2/page/82 82, 110]|publisher=John Wiley & Sons |url=https://archive.org/details/conciseencyclope0000unse_v5u2/page/82}}</ref> '''type coercion''',<ref name=":1" /> and '''type juggling'''<ref>{{Cite book|title=Pro TypeScript: Application-Scale JavaScript Development|last=Fenton|first=Steve|year=2017|isbn=978-1484232491|pages=xxiii|publisher=Apress }}</ref><ref>{{Cite web|url=http://php.net/manual/en/language.types.type-juggling.php|title=Type Juggling|website=PHP Manual|access-date=2019-01-27}}</ref> are different ways of changing an [[Expression (computer science)|expression]] from one [[data type]] to another. An example would be the conversion of an [[integer (computer science)|integer]] value into a [[floating point]] value or its textual representation as a [[string (computer science)|string]], and vice versa. Type conversions can take advantage of certain features of [[type hierarchy|type hierarchies]] or [[data representation]]s. Two important aspects of a type conversion are whether it happens ''implicitly'' (automatically) or ''explicitly'',<ref name=":0" /><ref name=":2">{{Cite book|title=C++ Quick Syntax Reference|last=Olsson|first=Mikael|year=2013|isbn=978-1430262770|pages=87–89|publisher=Apress }}</ref> 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.<ref name=":2"/><ref>{{Cite book|title=Computational Intelligence: A Methodological Introduction|isbn=978-1447172963|pages=269|last1=Kruse|first1=Rudolf|last2=Borgelt|first2=Christian|last3=Braune|first3=Christian|last4=Mostaghim|first4=Sanaz|last5=Steinbrecher|first5=Matthias|date=16 September 2016|publisher=Springer }}</ref> In general, both [[primitive data type|primitive]] and [[compound data type]]s 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 (program lifecycle phase)|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 [[Subroutine|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 (programming language)|Pascal]], [[Modula-2]], [[Ada (programming language)|Ada]] and [[Delphi (programming language)|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.

== Explicit casting in various languages ==

=== Ada ===
[[Ada (programming language)|Ada]] provides a generic library function Unchecked_Conversion.<ref>{{Cite web |title=Unchecked Type Conversions |url=https://www.adaic.org/resources/add_content/standards/95lrm/ARM_HTML/RM-13-9.html |access-date=2023-03-11 |website=Ada Information Clearinghouse}}</ref>

===C-like languages===

====Implicit type conversion====
Implicit type conversion, also known as ''coercion'' or ''type juggling'', is an automatic type conversion by the [[compiler]]. Some [[programming language]]s allow compilers to provide coercion; others require it.

In a mixed-type expression, data of one or more [[Subtyping|subtype]]s can be [[Operators in C and C++|converted]] to a supertype as needed at [[Run time (program lifecycle phase)|runtime]] so that the program will run correctly. For example, the following is legal [[C (programming language)|C language]] code:

<syntaxhighlight lang="c">
double  d;
long    l;
int     i;

if (d > i)   d = i;
if (i > l)   l = i;
if (d == l)  d *= 2;
</syntaxhighlight>

Although {{mono|'''d'''}}, {{mono|'''l'''}}, and {{mono|'''i'''}} 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 all possible values of some integer type. For example, {{C-lang|float}} 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:

<!-- an int is within - 32767(?) and 32767, isn't it ?! --> 
<syntaxhighlight lang="c">
#include <stdio.h>

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);
}
</syntaxhighlight>

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 {{C-lang|i_value}} to float when it is compared with {{C-lang|f_value}}. The conversion causes loss of precision, which makes the values equal before the comparison.

Important takeaways:

# {{C-lang|float}} to {{C-lang|int}} causes [[truncation]], i.e., removal of the fractional part.
# {{C-lang|double}} to {{C-lang|float}} causes rounding of digit.
# {{C-lang|long}} to {{C-lang|int}} causes dropping of excess higher order bits.

=====Type promotion=====
One special case of implicit type conversion is type promotion, where an object is automatically converted into another data type representing a [[superset]] of the original type. 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 (programming language)|Java]]:
<syntaxhighlight lang="java">
int x = 3;
double y = 3.5;
System.out.println(x + y); // The output will be 6.5
</syntaxhighlight>

====Explicit type conversion====
Explicit type conversion, also called type casting, is a type conversion which is explicitly defined within a program (instead of being done automatically according to the rules of the language for implicit type conversion). It is requested by the user in the program.

<syntaxhighlight lang="cpp">
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
</syntaxhighlight>

There are several kinds of explicit conversion.

; checked: Before the conversion is performed, a runtime check is done to see if the destination type can hold the source value. If not, an error condition is raised.
; unchecked: No check is performed. If the destination type cannot hold the source value, the result is undefined.
; bit pattern: The raw bit representation of the source is copied verbatim, and it is re-interpreted according to the destination type. This can also be achieved via [[Aliasing (computing)|aliasing]].

In [[object-oriented programming]] languages, objects can also be [[downcasting|downcast]] : a reference of a base class is cast to one of its derived classes.

===C# and C++===
In [[C Sharp (programming language)|C#]], type conversion can be made in a safe or unsafe (i.e., C-like) manner, the former called ''checked type cast''.<ref>
{{cite web
| access-date = 4 August 2011
| date       = 25 March 2002
| first      = Hanspeter
| last       = Mössenböck
| page       = 5
| publisher  = Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik
| title      = Advanced C#: Checked Type Casts
| url        = http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf}} at [http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/ C# Tutorial]
</ref>

<syntaxhighlight lang="csharp">
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
</syntaxhighlight>

In [[C++]] a similar effect can be achieved using ''C++-style cast syntax''.

<syntaxhighlight lang="cpp">
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

delete animal; // always free resources
animal = nullptr;
b = dynamic_cast<Bulldog*>(animal);         // b == nullptr
</syntaxhighlight>

===Eiffel===

In [[Eiffel (programming language)|Eiffel]] the notion of type conversion is integrated into the rules of the type system. The Assignment Rule says that an assignment, such as:
<syntaxhighlight lang="eiffel">
x := y
</syntaxhighlight>
is valid if and only if the type of its source expression, <code lang="eiffel">y</code> in this case, is ''compatible with'' the type of its target entity, <code lang="eiffel">x</code> 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 <code lang="eiffel">y</code> conforms to the type of <code lang="eiffel">x</code> if the class upon which <code lang="eiffel">y</code> is based is a descendant of that upon which <code lang="eiffel">x</code> is based.

====Definition of type conversion in Eiffel====
The actions of type conversion in Eiffel, specifically ''converts to'' and ''converts from'' are defined as:

<blockquote>
A type based on a class CU ''converts to'' a type T based on a class CT (and T ''converts from'' U) if either
:CT has a ''conversion procedure'' using U as a conversion type, or
:CU has a ''conversion query'' listing T as a conversion type
</blockquote>

====Example====

Eiffel is a fully compliant [[List of CLI languages|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 <code lang="eiffel">STRING_8</code>) from the Eiffel libraries, but Eiffel software written for .NET must use the .NET string class (<code lang="eiffel">System.String</code>) 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.

<syntaxhighlight lang="eiffel">
    my_string: STRING_8                 -- Native Eiffel string
    my_system_string: SYSTEM_STRING     -- Native .NET string

        ...

            my_string := my_system_string
</syntaxhighlight>

In the code above, two strings are declared, one of each different type (<code lang="eiffel">SYSTEM_STRING</code> is the Eiffel compliant alias for System.String). Because <code lang="eiffel">System.String</code> does not conform to <code lang="eiffel">STRING_8</code>, then the assignment above is valid only if <code lang="eiffel">System.String</code> converts to <code lang="eiffel">STRING_8</code>.

The Eiffel class <code lang="eiffel">STRING_8</code> has a conversion procedure <code lang="eiffel">make_from_cil</code> for objects of type <code lang="eiffel">System.String</code>. Conversion procedures are also always designated as creation procedures (similar to constructors). The following is an excerpt from the <code lang="eiffel">STRING_8</code> class:

<syntaxhighlight lang="eiffel">
    class STRING_8
        ...
    create
        make_from_cil
        ...
    convert
        make_from_cil ({SYSTEM_STRING})
        ...
</syntaxhighlight>

The presence of the conversion procedure makes the assignment:

<syntaxhighlight lang="eiffel">
            my_string := my_system_string
</syntaxhighlight>

semantically equivalent to:

<syntaxhighlight lang="eiffel">
            create my_string.make_from_cil (my_system_string)
</syntaxhighlight>

in which <code lang="eiffel">my_string</code> is constructed as a new object of type <code lang="eiffel">STRING_8</code> with content equivalent to that of <code lang="eiffel">my_system_string</code>.

To handle an assignment with original source and target reversed:

<syntaxhighlight lang="eiffel">
            my_system_string := my_string
</syntaxhighlight>

the class <code lang="eiffel">STRING_8</code> also contains a conversion query <code lang="eiffel">to_cil</code> which will produce a <code lang="eiffel">System.String</code> from an instance of <code lang="eiffel">STRING_8</code>.

<syntaxhighlight lang="eiffel">
    class STRING_8
        ...
    create
        make_from_cil
        ...
    convert
        make_from_cil ({SYSTEM_STRING})
        to_cil: {SYSTEM_STRING}
        ...
</syntaxhighlight>

The assignment:

<syntaxhighlight lang="eiffel">
            my_system_string := my_string
</syntaxhighlight>

then, becomes equivalent to:

<syntaxhighlight lang="eiffel">
            my_system_string := my_string.to_cil
</syntaxhighlight>

In Eiffel, the setup for type conversion is included in the class code, but then appears to happen as automatically as [[#Explicit type conversion|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 (programming language)|Rust]] provides no implicit type conversion (coercion) between primitive types. But, explicit type conversion (casting) can be performed using the <code>as</code> keyword.<ref>{{cite web |title=Casting |website=Rust by Example |url=https://doc.rust-lang.org/rust-by-example/types/cast.html |access-date=2025-04-01}}</ref>
<syntaxhighlight lang="rust">
let x = 1000;
println!("1000 as a u16 is: {}", x as u16);
</syntaxhighlight>

== Type assertion ==
A related concept in static type systems is called '''type assertion''', which instruct the compiler to treat the expression of a certain type, disregarding its own inference. Type assertion may be safe (a runtime check is performed) or unsafe. A type assertion does not convert the value from a data type to another.

=== TypeScript ===
In [[TypeScript]], a type assertion is done by using the <code>as</code> keyword:<ref>{{cite web|url=https://www.typescriptlang.org/docs/handbook/2/everyday-types.html|title=Everyday Types|website=The TypeScript Handbook|access-date=2025-04-01}}</ref>

<syntaxhighlight lang="typescript">
const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement;
</syntaxhighlight>

In the above example, <code>document.getElementById</code> is declared to return an <code>HTMLElement</code>, but you know that it always return an <code>HTMLCanvasElement</code>, which is a subtype of <code>HTMLElement</code>, in this case. If it is not the case, subsequent code which relies on the behaviour of <code>HTMLCanvasElement</code> will not perform correctly, as in Typescript there is no runtime checking for type assertions.

In Typescript, there is no general way to check if a value is of a certain type at runtime, as there is no runtime type support. However, it is possible to write a user-defined function which the user tells the compiler if a value is of a certain type of not. Such a function is called '''type guard''', and is declared with a return type of <code>x is Type</code>, where <code>x</code> is a parameter or <code>this</code>, in place of <code>boolean</code>.

This allows unsafe type assertions to be contained in the checker function instead of littered around the codebase.

=== Go ===
In [[Go (programming language)|Go]], a type assertion can be used to access a concrete type value from an interface value. It is a safe assertion that it will panic (in the case of one return value), or return a zero value (if two return values are used), if the value is not of that concrete type.<ref>{{cite web|url=https://go.dev/tour/methods/15|title=Type assertions|website=A Tour of Go|access-date=2025-04-01}}</ref>

<syntaxhighlight lang="go">
t := i.(T)
</syntaxhighlight>

This type assertions tell the system that <code>i</code> is of type <code>T</code>. If it isn't, it panics.

== Implicit casting using untagged unions ==
Many programming languages support [[Union type|union types]] which can hold a value of multiple types. ''Untagged'' unions are provided in some languages with loose type-checking, such as [[C (programming language)|C]] and [[PL/I]], but also in the original [[Pascal (programming language)|Pascal]]. These can be used to interpret the bit pattern of one type as a value of another type.

==Security issues==
In [[hacker (computer security)|hacking]], typecasting is the misuse of type conversion to temporarily change a [[variable (computer science)|variable]]'s data type from how it was originally defined.<ref>{{cite book |last=Erickson |first=Jon |title=Hacking: The Art of Exploitation |year=2008 |url=https://archive.org/details/HackingTheArtOfExploitation |publisher=No Starch Press |isbn=978-1-59327-144-2 |p=51 }} "Typecasting is simply a way to temporarily change a variable's data type, despite how it was originally defined. When a variable is typecast into a different type, the compiler is basically told to treat that variable as if it were the new data type, but only for that operation. The syntax for typecasting is as follows: <code>(typecast_data_type) variable</code> ..."</ref> 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.<ref>{{cite book |last=Gopal |first=Arpita |title=Magnifying C |year=2009 |url=https://books.google.com/books?id=XQqRyRdAqu0C&pg=PA59 |publisher=PHI Learning Private Limited |isbn=978-81-203-3861-6 |p=59 }} "From the above, it is clear that the usage of typecasting is to make a variable of one type, act like another type for one single operation. So by using this ability of typecasting it is possible for create ASCII characters by typecasting integer to its ..."</ref>

==See also==
* [[Downcasting]]
* {{section link|Run-time type information|C++ – dynamic cast and Java cast}}
* [[Truth value]]
* [[Type punning]]

==References==
{{Reflist}}

== External links ==
* [http://www.adapower.com/index.php?Command=Class&ClassID=FAQ&CID=354 Casting in Ada]
* [[Wikibooks:C++ Programming/Programming Languages/C++/Code/Statements/Variables/Type Casting|Casting in C++]]
* [https://web.archive.org/web/20160709112746/http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=285 C++ Reference Guide] Why I hate C++ Cast Operators, by Danny Kalev
* [https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.5 Casting in Java]
* [http://msdn.microsoft.com/en-us/library/aa691280(v=vs.71).aspx Implicit Conversions in C#]
* [http://cppreference.com/wiki/language/implicit_cast Implicit Type Casting at Cppreference.com]
* [http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/BitOp/cast.html Static and Reinterpretation castings in C++]
* [[Wikibooks:F Sharp Programming/Inheritance#Up-casting and Down-casting|Upcasting and Downcasting in F#]]

{{Data types}}

{{DEFAULTSORT:Type Conversion}}
[[Category:Data types]]
[[Category:Operators (programming)]]
[[Category:Type theory]]
[[Category:Unary operations]]