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