Starke Typisierung

Starke Typisierung (engl. strong typing, deutsch oft auch strenge Typisierung) bezeichnet ein Prinzip bei der Typisierung von Programmiersprachen, das allerdings nicht eindeutig definiert ist. In der Fachliteratur finden sich unterschiedlich strenge Definitionen. Man kann aber generell zwischen Sprachen ohne oder sehr schwacher Typisierung (z.B. PHP) oder stärkerer Typisierung (u.a. C++) unterscheiden. Oft hängt strenge mit statischer Typisierung zusammen und erweitert diese.

Bei dynamischer Typisierung im Rahmen von Referenzvariablen, Vererbung oder Polymorphie, letztere können oft erst zur Laufzeit der entsprechenden Programme überprüft werden, gibt es sehr große Unterschiende in der Stärke der Typisierung. Programmiersprachen die bei dynamischen Variablen nur sehr schwach typisiert sind, wie C oder C++, erlauben die Zuweisung von beliebigen Adressen an Referenzvariablen. Sehr rigoros entworfene Programmiersprachen erlauben nur streng kompatible Zuweisungen, viele Programmiersprachen tolerieren jedoch aus praktischen Erwägungen implizite Typenumwandlungen ohne oder mit vernachlässigbarem Informationsverlust.

Starke Typisierung wird meist als Vergleich denn als absolute Bezeichnung genutzt: Sprache X ist stärker/strenger typisiert als Sprache Y. Bei solchen Vergleichen spielt sehr oft das Vorhandensein impliziter oder auch expliziter Konvertierungen eine Rolle; so ist PHP deshalb schwächer typisiert als C, weil PHP fast überall implizit konvertiert, C jedoch nur bei ähnlichen Typen. C++ ist wiederum deshalb stärker typisiert als C, da z.B. implizite Umwandlungen von void- in beliebige andere Pointer nicht erlaubt sind. Noch stärker typisiert ist wiederum Delphi, das im Gegensatz zu C++ keine impliziten Konvertierungen zwischen Boolean- und Integer-Werten vornimmt. Und Haskell erlaubt noch nicht einmal implizite Konvertierungen von Ganz- in Fließkommazahlen.

Der Sinn einer starken Typisierung ist, Programmierfehler zu vermeiden, die entstehen können, wenn der Compiler oder Interpreter nicht auf gefährliche, implizite (nicht ausdrücklich ausgezeichnete) Typkonvertierungen hinweist - beispielsweise würde in der Skriptsprache Perl (ohne use strict, eine Compiler-Anweisung, die den Compiler darauf hinweist, eine sehr strenge Prüfung vorzunehmen) der String "4" implizit in den Integer 4 umgewandelt, jedoch der z.B. durch Tippfehler entstehende String "e4" in den Integer 0. In C dürfte (alleine wegen der völlig unterschiedlichen Repräsentation von Strings und Integern) solch eine Umwandlung nicht durchgeführt werden.

Verschiedene Definitionen

(absteigend nach Strenge der jeweiligen Definition)

• Nichtvorhandensein irgendwelcher Konvertierungsmethoden und keine Möglichkeit, das Typsystem auf irgendeine Weise zu umgehen
• Nur explizite Konvertierungen möglich
• Typüberprüfung zur Übersetzungs- statt zur Laufzeit (statische Typisierung vs. dynamische Typisierung)
• Implizite Konvertierungen nur zwischen ähnlichen Typen (zum Beispiel zwei unterschiedlichen Ganzzahl-Typen, siehe auch Zuweisungskompatibilität)
• Generelle Unterscheidung zwischen Typen (z.B. hat Tcl keine verschiedenen Typen)

Vor- und Nachteile

Vorteile strenger Typisierung sind zum Beispiel^[1]

• Performanzgewinn durch das Vermeiden zeitaufwendiger Typumwandlungen
• Optimierungsmöglichkeiten
• Zurückweisung von fehlerhaftem Code schon zur Übersetzungszeit (besonders wichtig für hochkritische Einsatzgebiete, zum Beispiel Flugzeug- oder Satellitensteuerung)
• Frühzeitige Erkennung von Programmierfehlern mit der Reduktion des Aufwandes für die Fehlersuche mit entsprechendem Zeit- und Effizienzgewinn bei der Implementierung

Nachteile sind unter anderem:

• Mehrfachverwendung von Code ist teilweise eingeschränkt (es müssen eigene Funktionen für teilweise sehr ähnliche Typen geschrieben werden), was jedoch durch Vererbung von Programmcode beziehungsweise durch Polymorphie beispielsweise im Rahmen der generischen Programmierung nicht nur vermieden, sondern sogar besonders elegant und wohlstrukturiert gelöst werden kann.

Realisierung strenger Typisierung in verschiedenen Programmiersprachen

• C besitzt eine relativ starke Typisierung, erlaubt allerdings in sehr vielen Situationen eine implizite oder explizite Umwandlung.
• C++ hat ein gegenüber C erweitertes Typsystem (aufgrund der Objektorientierung lassen sich eigene Typen definieren), in diesem sind implizite und explizite Umwandlungen insbesondere zwischen neu definierten Typen (Klassen) strenger geregelt; z.B. dürfen Objektpointer nur dann implizit in einen Pointer auf ein Objekt der Basisklasse umgewandelt werden, falls die Vererbung public ist. Außerdem dürfen im Gegensatz zu C void-Pointer nicht in Pointer auf beliebige Objekte umgewandelt werden, es muss eine explizite Umwandlung vorgenommen werden. In C wird eine implizite Konvertierung ausgeführt.
• In C, C++, Java, C#, Pascal und Ada müssen alle Variablen einen Typ besitzen.
• Perl hat nur sehr eingeschränkt eine starke Typisierung: Nur bei gewünscht strenger Typisierung wird bei eventuell nicht-gewollten Umwandlungen eine Warnung ausgegeben.
• Python besitzt zwar eine relativ starke Typisierung, allerdings wird dies für den Programmierer nicht ersichtlich (Variablen sind nur typlose Referenzen auf Objekte); Duck-Typing wird verwendet.
• OCAML und Haskell erlauben keinerlei implizite Typwandlungen.
• Visual Basic besitzt sowohl statisch typisierte Variablen als auch den Variant-Typ, der jegliche Typen enthalten darf.
• Assemblersprache und Forth^[2] besitzen keine Typisierung; allein der Programmierer darf/muss die Typüberprüfung erledigen.

Einzelnachweise

1. ↑ http://www.christoph-probst.com/uni/presentations/files/20010731-ut/20010731-ut_Ausarbeitung.pdf
2. ↑ http://rosettacode.org/wiki/Category:Forth