casting

 

or founding, shaping of metal by melting and pouring into a mold. Most castings, especially large ones, are made in sand molds. Sand, mixed with a binder to hold it together, is pressed around a wooden pattern that leaves a cavity in the sand. Molten metal is poured into the cavity and allowed to solidify. Permanent metal molds are used to make many small, simple parts; shell molding gives greater accuracy for a large volume of semiprecision parts. A two-step process, investment casting, produces small, complex shapes. Wax or plastic replicas of the parts are molded in accurate metal molds. These replicas are covered with sand in a box to make the final mold. When the whole mold is heated, the replica melts, leaving behind a cavity into which metal is poured. Large numbers of small, precise parts of metals that have a low melting point, such as zinc, are made by die-casting; in an automatic process, molten metal is forced under pressure into metal molds. Cast iron and cast steel are more brittle than forged iron and forged steel (see forging).

For other meanings, see typecasting.

In computer science, type conversion or typecasting refers to changing an entity of one data type into another. This is done to take advantage of certain features of type hierarchies. For instance, values from a more limited set, such as integers, can be stored in a more compact format and later converted to a different format enabling operations not previously possible, such as division with several decimal places' worth of accuracy. In object-oriented programming languages, type conversion allows programs to treat objects of one type as one of their ancestor types to simplify interacting with them.

There are two types of conversion: implicit and explicit. The term for implicit type conversion is coercion. The most common form of explicit type conversion is known as casting. Explicit type conversion can also be achieved with separately defined conversion routines such as an overloaded object constructor.

Implicit type conversion

Implicit type conversion, also known as coercion, is an automatic type conversion by the compiler. Some languages allow, or even require, compilers to provide coercion.

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 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 floating-point representations are converted to integral representations as the fractional components of the floating-point values will be truncated (rounded down). Conversely, converting from an integral representation to a floating-point one can also lose precision, since the floating-point type may be unable to represent the integer exactly (for example, 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 situations such as storing the same integer value into two variables of type int and type single which return false if compared for equality.

Explicit type conversion

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 data is not interpreted at all, and its raw bit representation is copied verbatim. This can also be achieved via aliasing.

Each programming language has its own rules on how types can be converted. In general, both objects and fundamental data types can be converted.

Static cast

In [[C++]] the static_cast operator changes expressions of one static type to objects and values of another static type.

 static_cast<type> (object);

The type parameter must be a data type for which there is a known method for converting object to, whether this be a builtin or through a casting function. It can be a reference or an enumerator.

The static_cast operator can be used for operations such as

• Converting a pointer to a base class to a pointer to a derived class,
• Convert numeric data types such as enums to ints or ints to floats.

However, static_cast conversions are not necessarily safe as no run-time type check is done which can cause casting between incompatible data types, for example pointers. However, this is checked at compile time to prevent casting obviously incompatibles. Also, sometimes static_cast between pointer to base to pointer to derived will produce an erroneous result, because of the object layout model.

See also

• Type punning

External Resources

• Casting in Ada
• Casting in Java
• Comparison of Casting in ABAP and Java

Donate to Wikimedia