Typecast

from Wikipedia, the free encyclopedia

In computer science, type conversion ( English type conversion or type casting ) is the conversion of one data type into another in order to avoid a type violation that is given by a lack of assignment compatibility .

A distinction is made between

  1. explicit and implicit casts;
  2. value-preserving and lossy type conversion;
  3. User-defined and predefined (“built-in”) type conversion.

With the explicit type conversion, the type conversion is explicitly written in the program code . Depending on the typing of the programming language used , the lack of an explicit specification of the type conversion can result in a runtime or compile time error.

In contrast, implicit casts do not appear in the source code . They are carried out either in accordance with regulations specified by the respective programming language or in accordance with a procedure defined by the programmer elsewhere in the source text. This makes them a potential source of error if used inadvertently. Many programming languages, such as B. Java , only perform implicit type conversion if it can take place without loss of information, i.e. if the target data type has the same or a larger range of values than the output data type .

Type extension and type restriction

Since different data types often have different value ranges, type extensions , i.e. enlargements of the value range, or type restrictions , i.e. reduction of the value range, can occur during the type conversion .

For example, if an integer with a size of 16 bits is converted into a 32-bit integer, it is a type extension. In the opposite case, this would be a type restriction.

Examples

Java

// Explizite Typumwandlung
int i = 100;
byte b = (byte) i;

// Implizite Typumwandlung
int j = 12;
double d = j;

// Bei Zeichenketten wird beim expliziten Casten String.valueOf(x)
// bzw. bei Objekten x.toString() aufgerufen:

int i = 164;
String str = String.valueOf(i);

// Implizite Typumwandlung bei Zeichenketten

int i = 164;
String str = "" + i;

// Implizite Typumwandlung als Fehlerquelle
int g = 9;
double e = g/2; // e ist nicht 4.5, sondern 4.0, da der zweite Operand eine Ganzzahl ist.
                // Daher wird eine Ganzzahldivison durchgeführt und deren Ergebnis ist 4.
                // Anschließend findet erst die Typumwandlung auf double statt und e weist den Wert 4.0 auf

// Um dieses Verhalten zu umgehen, muss der zweite Operand als Gleitkommazahl gekennzeichnet werden
// z. B. indem man statt der 2 eine 2.0 schreibt
int z = 9;
double y = z/2.0;
// oder wieder eine explizite Typumwandlung benutzt
int z = 9;
double y = z/(double)2;

C # 

Geraet geraet = new Computer();

Bildschirm bildschirm = (Bildschirm) geraet;  // Wenn (geraet is Bildschirm), stat.type(geraet) is Bildschirm, sonst wird eine Exception geworfen
bildschirm = geraet as Bildschirm;  // Wenn (geraet is Bildschirm), bildschirm = (Bildschirm) geraet, sonst bildschirm = null

geraet = null;
bildschirm = geraet as Bildschirm;  // bildschirm == null

C ++ 

Geraet* geraet = new Computer;

Bildschirm* bildschirm = static_cast<Bildschirm*>(geraet);  // Kompiliert nur, wenn entweder Geraet or Bildschirm von der anderen oder derselben Klasse abgeleitet ist
bildschirm = dynamic_cast<Bildschirm*>(geraet);  // Wenn (geraet is Bildschirm), dann bildschirm = (Bildschirm*) geraet, sonst bildschirm = nullptr

Bildschirm& bildschirmR = static_cast<Bildschirm&>(*geraet);  // Wie oben, aber eine Exception wird geworfen, wenn ein nullptr zurückgegeben wird

geraet = nullptr;
bildschirm = dynamic_cast<Bildschirm*>(geraet);  // bildschirm == nullptr

delete geraet;  // gibt die Ressourcen frei

See also

Web links