Typisierung (Informatik)
aus Wikipedia, der freien Enzyklopädie
Eine Typisierung (engl. typing) dient in der Informatik dazu, dass die Objekte (hier Objekte im mathematisch-abstrakten Sinne verstanden) der Programmiersprachen, wie z.B. Variablen, Funktionen oder Objekte (im Sinne der objektorientierten Programmierung) korrekt verwendet werden. Das Hauptziel ist die Vermeidung von Laufzeitfehlern. Ein umgangssprachliches Beispiel für die dahinter liegende Problematik ist, dass man nicht Äpfel mit Birnen vergleichen soll.
Typen liefern Bedingungen, deren Einhaltung bzw. Verletzung bei der Übersetzung oder späteren Ausführung vom Typsystem kontrolliert werden kann und somit eine Maßnahme gegen Programmierfehler darstellt.
Damit greift man eine Idee aus der Mathematik auf, speziell der Typentheorie, die durch die Entdeckung von Widersprüchen in der Mengenlehre in eine Grundlagenkrise geraten war, bis man sich darauf besann, genauer darauf zu achten, welche Objekte wie benutzt werden.
[Bearbeiten] Kategorien
Man unterscheidet drei Kategorien, in die sich ein Typsystem einordnen lässt:
- starke Typisierung (strong typing) und schwache Typisierung (weak typing)
- Wie streng unterscheidet die Sprache die Datentypen?
- dynamische Typisierung (dynamic typing) und statische Typisierung (static typing)
- Wann werden die Datentypen festgelegt, zur Übersetz- oder zur Laufzeit?
- explizite Typisierung (explicit typing) und implizite Typisierung (implicit typing)
- Werden die Datentypen explizit genannt oder via Typinferenz abgeleitet?
[Bearbeiten] Beispiele
Die folgenden Beispiele sollen die Kategorien verdeutlichen, die Einordnung von Sprachen in diese Kategorien ist aber bis zu einem gewissen Grad subjektiv (C++ z. B. ist stärker getypt als C, aber schwächer als OCAML), und viele Typsysteme haben je nach Verwendung mehrere Aspekte (Polymorphe Werte, Typumwandlung etc.).
Statisch, implizit, stark: OCAML
let myAdd a b = (* Wir definieren eine Funktion, die zwei nicht näher bezeichnete Werte nimmt *) a +. b;; (* +. ist der Additionsoperator für Fließkommazahlen *) (* val myAdd : float -> float -> float = <fun> *) (* Ocaml hat von selbst erkannt, dass diese Funktion zwei Fließkommazahlen erwartet und eine zurückgibt *) myAdd 1 2.5;; (* Addiere zwei Zahlen, aber eine davon ist eine Ganzzahl *) (* Compilerfehler: This expression has type int but is here used with type float *) myAdd (float_of_int 1) 2.5;; (* Addiere zwei Zahlen, wandle Ganzzahl zuvor in Fließkommazahl um, ergibt 3.5 *)
Statisch, explizit, schwach: C
int x; // Weise x explizit den Typ int (Ganzzahl) zu.
printf("%f", x); // Gib x als Fließkommazahl aus (Ohne Umwandlung, Ergebnis undefiniert, evt. Programmabruch)
Dynamisch, implizit, schwach: PHP
$x = 1; // Weise x explizit den Wert 1 zu (und damit implizit den Typ int). $x = 2 + "42"; // Addiere eine Zahl und eine Zeichenkette, wandle dazu die Zeichenkette in eine Zahl um // $x ist jetzt 44 $x = 2 + "Ich bin keine Zahl"; // Wie oben, ungültige Zeichenkette wird zu 0 umgewandelt // $x ist jetzt 2
Dynamisch, implizit, stark: Python
x = 1 # Weise x explizit den Wert 1 zu (und damit implizit den Typ int).
x = 2 + "42" # Addiere eine Zahl und eine Zeichenkette, Laufzeitfehler ("TypeError")
x = 2 + int("42") # Addiere eine Zahl und eine Zahl, die aus einer Zeichenkette erstellt wird
# x ist jetzt 44
x = 2 + int("Ich bin keine Zahl") # Laufzeitfehler ("ValueError")
Statisch und dynamisch, explizit, stark: Pike
int x = 1; // Definiere x als int und weise explizit den Wert 1 zu.
x = 2 - "42"; // Subtrahiere eine Zeichenkette von einer Zahl, Kompilier- oder Laufzeitfehler ("Bad argument 2 to `-.")
x = "42"; // Weise x den wert "42" zu. Kompilierfehler ("Bad type in assignment")
x = 2 + (int)"42"; // Addiere eine Zahl und eine Zahl, die aus einer Zeichenkette erstellt wird
// x ist jetzt 44
x = 2 + (int)"Ich bin keine Zahl" // Ungültige Zeichenkette wird zu 0 umgewandelt
// x ist jetzt 2
