Wie unterscheiden sich Programmiersprachen? – Typisierung

Die Typisierung in der Softwareprogrammierung beschreibt ein Regelwerk, um sicherzustellen, dass keine Operationen ausgeführt werden, die syntaktisch oder semantisch fehlerhaft sind. Programmiersprachen, welche über ein solches System verfügen, werden typisiert genannt. Weiter wird, gemessen an der Ausprägung des Systems, zwischen stark typisiert oder schwach typisiert Sprachen unterschieden.
Klassifikation
Ein Typsystem lässt sich in drei Dimensionen klassifizieren:
- starke Typisierung (strongly typed) und schwache Typisierung (weakly typed)
Wie streng unterscheidet die Sprache die Typen?
Welche Datentypen können ineinander umgewandelt werden? - dynamische Typisierung (dynamicly typed) und statische Typisierung (staticly typed)
Typprüfungen können zur Kompilierzeit (statische Prüfung) oder zur Laufzeit (dynamische Prüfung) vorgenommen werden. - explizite Typisierung (explizitly typing) und implizite Typisierung (implicitly typing)
Werden die Datentypen explizit genannt oder per Typableitung (type inference) ermittelt?
Beispiele
Assembler
Kein Typsystem
mov ah, 0x0e ; Weise dem oberen Byte des Registers a den Wert 14 zu.
mov al, '!' ; Weise dem unteren Byte den Wert des Zeichens '!' zu.
int 0x10 ; Erzeuge Interrupt 0x10 um das Zeichen '!' auszugeben.
C
Statisch, explizit, schwach
int x; // Weise x explizit den Typ int (Ganzzahl) zu.
char *str = x; // Weist str als Anfangsadresse den Wert von x zu.
// Da x undefiniert ist, kann die Ausgabe von str zum Programmabsturz führen.
x = &str; // Weist x die Speicheradresse von str zu.
*(char **)x = "text"; // Schreibt die Anfangsadresse des Strings "text" in die Adresse von str.
printf("%s", str); // Ausgabe von "text"
C#
Statisch und dynamisch, explizit und implizit, stark
object addmax(object a, int b, short c)
{
int max = Math.Max(b, c); // Aufruf von Max(int b, int c) der Klasse Math
int sum = (int)a + max; // InvalidCastException falls a nicht konvertierbar,
// NullReferenceException falls a undefiniert
return sum; // implizite Konvertierung (Boxing) von int zu object
}
Java
Statisch, explizit, stark
Integer addmax(Object a, int b, short c) {
int max = Math.max(b, c); // Aufruf von max(int b, int c) der Klasse Math
int sum = (int)a + max; // ClassCastException falls a nicht konvertierbar,
// NullPointerException falls a undefiniert
return sum; // implizite Konvertierung (boxing) zu Integer
}
PHP
Dynamisch, implizit, schwach
$x = 1; // Weise x explizit den Wert 1 zu.
$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
Python
Dynamisch, implizit, stark
x = 1 # Weise x explizit den Wert 1 zu.
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")
Swift
Statisch, implizit, stark
func addmax(a: NSNumber, b: Int, c: Double) -> Int {
let m = max(b, c) // Aufruf von max(b: Int, c: Int) von der Swift Standard Library (Typ von m ist impliziert als Int)
let sum: Int = Int(a) + m // ClassCastException falls a nicht konvertierbar (Typ von sum ist explizit als Int)
return sum
}
Objective-C
Statisch, explizit, stark
- (int) max:(int) num1 secondNumber:(int) num2 {
int result;
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
Related
- 12. März 2018
-
Christian Seiler
- Programming
- Guidelines, Programming Language, Typsystem