Menu
Home
People
Places
Arts
History
Plants & Animals
Science
Life & Culture
Technology
Reference.org
Type conversion
open-in-new
<h2 id="explicit-casting-in-various-languages">Explicit casting in various languages</h2> <h3>Ada</h3> <p><a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada</a> provides a generic library function Unchecked_Conversion.<a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a> </p> <h3>C-like languages</h3> <h4>Implicit type conversion</h4> <p>Implicit type conversion, also known as <i>coercion</i> or <i>type juggling</i>, is an automatic type conversion by the <a href="/facts/Compiler/WNfCDFJe">compiler</a>. Some <a href="/facts/Programming_language/cWTYbgWa">programming languages</a> allow compilers to provide coercion; others require it. </p><p>In a mixed-type expression, data of one or more <a href="/facts/Subtyping/0L9t8twv">subtypes</a> can be <a href="/facts/Operators_in_C_and_C%2B%2B/6sAAkUBM">converted</a> to a supertype as needed at <a href="/facts/Run_time_(program_lifecycle_phase)/lCxKsrzB">runtime</a> so that the program will run correctly. For example, the following is legal <a href="/facts/C_(programming_language)/Ky2No763">C language</a> code: </p> double d; long l; int i; if (d > i) d = i; if (i > l) l = i; if (d == l) d *= 2; <p>Although d, l, and 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, float might be an <a href="/facts/IEEE_754/dD3e7zAl">IEEE 754</a> 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: </p> #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); } <p>On compilers that implement floats as IEEE single precision, and ints as at least 32 bits, this code will give this peculiar print-out: </p> The integer is: 16777217 The float is: 16777216.000000 Their equality: 1 <p>Note that 1 represents equality in the last line above. This odd behavior is caused by an implicit conversion of i_value to float when it is compared with f_value. The conversion causes loss of precision, which makes the values equal before the comparison. </p><p>Important takeaways: </p> <ol><li>float to int causes <a href="/facts/Truncation/8mEHh0qp">truncation</a>, i.e., removal of the fractional part.</li> <li>double to float causes rounding of digit.</li> <li>long to int causes dropping of excess higher order bits.</li></ol> <h5>Type promotion</h5> <p>One special case of implicit type conversion is type promotion, where an object is automatically converted into another data type representing a <a href="/facts/Superset/SJGERmbA">superset</a> of the original type. Promotions are commonly used with types smaller than the native type of the target platform's <a href="/facts/Arithmetic_logic_unit/SgIjPzSc">arithmetic logic unit</a> (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. </p><p>In <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>: </p> int x = 3; double y = 3.5; System.out.println(x + y); // The output will be 6.5 <h4>Explicit type conversion</h4> <p>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. </p> 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 <p>There are several kinds of explicit conversion. </p> 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 <a href="/facts/Aliasing_(computing)/C7wT3dQy">aliasing</a>. <p>In <a href="/facts/Object-oriented_programming/TxNMEcao">object-oriented programming</a> languages, objects can also be <a href="/facts/Downcasting/YGVouRuJ">downcast</a> : a reference of a base class is cast to one of its derived classes. </p> <h3>C# and C++</h3> <p>In <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, type conversion can be made in a safe or unsafe (i.e., C-like) manner, the former called <i>checked type cast</i>.<a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a> </p> 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 <p>In <a href="/facts/C%2B%2B/Et0F2qn9">C++</a> a similar effect can be achieved using <i>C++-style cast syntax</i>. </p> 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 <h3>Eiffel</h3> <p>In <a href="/facts/Eiffel_(programming_language)/gEzPjzmn">Eiffel</a> the notion of type conversion is integrated into the rules of the type system. The Assignment Rule says that an assignment, such as: </p> x := y <p>is valid if and only if the type of its source expression, y in this case, is <i>compatible with</i> the type of its target entity, x in this case. In this rule, <i>compatible with</i> means that the type of the source expression either <i>conforms to</i> or <i>converts to</i> that of the target. Conformance of types is defined by the familiar rules for <a href="/facts/Polymorphism_in_object-oriented_programming/S3cCKsVT">polymorphism in object-oriented programming</a>. For example, in the assignment above, the type of y conforms to the type of x if the class upon which y is based is a descendant of that upon which x is based. </p> <h4>Definition of type conversion in Eiffel</h4> <p>The actions of type conversion in Eiffel, specifically <i>converts to</i> and <i>converts from</i> are defined as: </p> <blockquote> <p>A type based on a class CU <i>converts to</i> a type T based on a class CT (and T <i>converts from</i> U) if either </p> CT has a <i>conversion procedure</i> using U as a conversion type, or CU has a <i>conversion query</i> listing T as a conversion type </blockquote> <h4>Example</h4> <p>Eiffel is a fully compliant <a href="/facts/List_of_CLI_languages/LnpaWLBK">language</a> for Microsoft <a href="/facts/.NET_Framework/J6QDAUhP">.NET Framework</a>. 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 STRING_8) from the Eiffel libraries, but Eiffel software written for .NET must use the .NET string class (System.String) 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. </p> my_string: STRING_8 -- Native Eiffel string my_system_string: SYSTEM_STRING -- Native .NET string ... my_string := my_system_string <p>In the code above, two strings are declared, one of each different type (SYSTEM_STRING is the Eiffel compliant alias for System.String). Because System.String does not conform to STRING_8, then the assignment above is valid only if System.String converts to STRING_8. </p><p>The Eiffel class STRING_8 has a conversion procedure make_from_cil for objects of type System.String. Conversion procedures are also always designated as creation procedures (similar to constructors). The following is an excerpt from the STRING_8 class: </p> class STRING_8 ... create make_from_cil ... convert make_from_cil ({SYSTEM_STRING}) ... <p>The presence of the conversion procedure makes the assignment: </p> my_string := my_system_string <p>semantically equivalent to: </p> create my_string.make_from_cil (my_system_string) <p>in which my_string is constructed as a new object of type STRING_8 with content equivalent to that of my_system_string. </p><p>To handle an assignment with original source and target reversed: </p> my_system_string := my_string <p>the class STRING_8 also contains a conversion query to_cil which will produce a System.String from an instance of STRING_8. </p> class STRING_8 ... create make_from_cil ... convert make_from_cil ({SYSTEM_STRING}) to_cil: {SYSTEM_STRING} ... <p>The assignment: </p> my_system_string := my_string <p>then, becomes equivalent to: </p> my_system_string := my_string.to_cil <p>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. </p> <h3>Rust</h3> <p><a href="/facts/Rust_(programming_language)/8JNMV19F">Rust</a> provides no implicit type conversion (coercion) between primitive types. But, explicit type conversion (casting) can be performed using the as keyword.<a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a> </p> let x = 1000; println!("1000 as a u16 is: {}", x as u16); <h2 id="type-assertion">Type assertion</h2> <p>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. </p> <h3>TypeScript</h3> <p>In <a href="/facts/TypeScript/W9J27V1N">TypeScript</a>, a type assertion is done by using the as keyword:<a class="footnote-ref" id="fnref:15" href="#fn:15"><sup>15</sup></a> </p> const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement; <p>In the above example, document.getElementById is declared to return an HTMLElement, but you know that it always return an HTMLCanvasElement, which is a subtype of HTMLElement, in this case. If it is not the case, subsequent code which relies on the behaviour of HTMLCanvasElement will not perform correctly, as in Typescript there is no runtime checking for type assertions. </p><p>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 x is Type, where x is a parameter or this, in place of boolean. </p><p>This allows unsafe type assertions to be contained in the checker function instead of littered around the codebase. </p> <h3>Go</h3> <p>In <a href="/facts/Go_(programming_language)/oWlsmAFJ">Go</a>, 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.<a class="footnote-ref" id="fnref:16" href="#fn:16"><sup>16</sup></a> </p> t := i.(T) <p>This type assertions tell the system that i is of type T. If it isn't, it panics. </p> <h2 id="implicit-casting-using-untagged-unions">Implicit casting using untagged unions</h2> <p>Many programming languages support <a href="/facts/Union_type/GSV1DsyV">union types</a> which can hold a value of multiple types. <i>Untagged</i> unions are provided in some languages with loose type-checking, such as <a href="/facts/C_(programming_language)/Ky2No763">C</a> and <a href="/facts/PL/I/469mVYgd">PL/I</a>, but also in the original <a href="/facts/Pascal_(programming_language)/b3yvp8bF">Pascal</a>. These can be used to interpret the bit pattern of one type as a value of another type. </p> <h2 id="security-issues">Security issues</h2> <p>In <a href="/facts/Hacker_(computer_security)/4bAJ9F1A">hacking</a>, typecasting is the misuse of type conversion to temporarily change a <a href="/facts/Variable_(computer_science)/VoCKtwml">variable</a>'s data type from how it was originally defined.<a class="footnote-ref" id="fnref:17" href="#fn:17"><sup>17</sup></a> 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.<a class="footnote-ref" id="fnref:18" href="#fn:18"><sup>18</sup></a> </p> <h2 id="see-also">See also</h2> <ul><li><a href="/facts/Downcasting/YGVouRuJ">Downcasting</a></li> <li><a href="/facts/Run-time_type_information/z08ojlmN">Run-time type information § C++ – dynamic cast and Java cast</a></li> <li><a href="/facts/Truth_value/SY4e2w8l">Truth value</a></li> <li><a href="/facts/Type_punning/xYtejQnM">Type punning</a></li></ul> <h2 id="external-links">External links</h2> <ul><li><a href="http://www.adapower.com/index.php?Command=Class&ClassID=FAQ&CID=354">Casting in Ada</a></li> <li>Casting in C++</li> <li><a href="https://web.archive.org/web/20160709112746/http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=285">C++ Reference Guide</a> Why I hate C++ Cast Operators, by Danny Kalev</li> <li><a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.5">Casting in Java</a></li> <li><a href="http://msdn.microsoft.com/en-us/library/aa691280(v=vs.71).aspx">Implicit Conversions in C#</a></li> <li><a href="http://cppreference.com/wiki/language/implicit_cast">Implicit Type Casting at Cppreference.com</a></li> <li><a href="http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/BitOp/cast.html">Static and Reinterpretation castings in C++</a></li> <li>Upcasting and Downcasting in F#</li></ul> <h2 id="references">References</h2> <ol> <li id="fn:1"><p>Mehrotra, Dheeraj (2008). S. Chand's Computer Science. S. Chand. pp. 81–83. ISBN 978-8121929844. <a href="978-8121929844" target="_blank">978-8121929844</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li> <li id="fn:2"><p>Programming Languages - Design and Constructs. Laxmi Publications. 2013. p. 35. ISBN 978-9381159415. <a href="978-9381159415" target="_blank">978-9381159415</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li> <li id="fn:3"><p>Mehrotra, Dheeraj (2008). S. Chand's Computer Science. S. Chand. pp. 81–83. ISBN 978-8121929844. <a href="978-8121929844" target="_blank">978-8121929844</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li> <li id="fn:4"><p>Reilly, Edwin (2004). Concise Encyclopedia of Computer Science. John Wiley & Sons. pp. 82, 110. ISBN 0470090952. <a href="0470090952" target="_blank">0470090952</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li> <li id="fn:5"><p>Reilly, Edwin (2004). Concise Encyclopedia of Computer Science. John Wiley & Sons. pp. 82, 110. ISBN 0470090952. <a href="0470090952" target="_blank">0470090952</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li> <li id="fn:6"><p>Fenton, Steve (2017). Pro TypeScript: Application-Scale JavaScript Development. Apress. pp. xxiii. ISBN 978-1484232491. <a href="978-1484232491" target="_blank">978-1484232491</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li> <li id="fn:7"><p>"Type Juggling". PHP Manual. Retrieved 27 January 2019. <a href="http://php.net/manual/en/language.types.type-juggling.php" target="_blank">http://php.net/manual/en/language.types.type-juggling.php</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li> <li id="fn:8"><p>Mehrotra, Dheeraj (2008). S. Chand's Computer Science. S. Chand. pp. 81–83. ISBN 978-8121929844. <a href="978-8121929844" target="_blank">978-8121929844</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li> <li id="fn:9"><p>Olsson, Mikael (2013). C++ Quick Syntax Reference. Apress. pp. 87–89. ISBN 978-1430262770. <a href="978-1430262770" target="_blank">978-1430262770</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li> <li id="fn:10"><p>Olsson, Mikael (2013). C++ Quick Syntax Reference. Apress. pp. 87–89. ISBN 978-1430262770. <a href="978-1430262770" target="_blank">978-1430262770</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li> <li id="fn:11"><p>Kruse, Rudolf; Borgelt, Christian; Braune, Christian; Mostaghim, Sanaz; Steinbrecher, Matthias (16 September 2016). Computational Intelligence: A Methodological Introduction. Springer. p. 269. ISBN 978-1447172963. <a href="978-1447172963" target="_blank">978-1447172963</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li> <li id="fn:12"><p>"Unchecked Type Conversions". Ada Information Clearinghouse. Retrieved 11 March 2023. <a href="https://www.adaic.org/resources/add_content/standards/95lrm/ARM_HTML/RM-13-9.html" target="_blank">https://www.adaic.org/resources/add_content/standards/95lrm/ARM_HTML/RM-13-9.html</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li> <li id="fn:13"><p>Mössenböck, Hanspeter (25 March 2002). "Advanced C#: Checked Type Casts" (PDF). Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik. p. 5. Retrieved 4 August 2011. at C# Tutorial <a href="http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf" target="_blank">http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li> <li id="fn:14"><p>"Casting". Rust by Example. Retrieved 1 April 2025. <a href="https://doc.rust-lang.org/rust-by-example/types/cast.html" target="_blank">https://doc.rust-lang.org/rust-by-example/types/cast.html</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li> <li id="fn:15"><p>"Everyday Types". The TypeScript Handbook. Retrieved 1 April 2025. <a href="https://www.typescriptlang.org/docs/handbook/2/everyday-types.html" target="_blank">https://www.typescriptlang.org/docs/handbook/2/everyday-types.html</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></p></li> <li id="fn:16"><p>"Type assertions". A Tour of Go. Retrieved 1 April 2025. <a href="https://go.dev/tour/methods/15" target="_blank">https://go.dev/tour/methods/15</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></p></li> <li id="fn:17"><p>Erickson, Jon (2008). Hacking: The Art of Exploitation. No Starch Press. p. 51. ISBN 978-1-59327-144-2. "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: (typecast_data_type) variable ..." <a href="978-1-59327-144-2" target="_blank">978-1-59327-144-2</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></p></li> <li id="fn:18"><p>Gopal, Arpita (2009). Magnifying C. PHI Learning Private Limited. p. 59. ISBN 978-81-203-3861-6. "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 ..." <a href="978-81-203-3861-6" target="_blank">978-81-203-3861-6</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></p></li> </ol>