Starke Typisierung

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Dieser Artikel ist nicht hinreichend mit Belegen (beispielsweise Einzelnachweisen) ausgestattet. Die fraglichen Angaben werden daher möglicherweise demnächst entfernt. Bitte hilf der Wikipedia, indem du die Angaben recherchierst und gute Belege einfügst. Näheres ist eventuell auf der Diskussionsseite oder in der Versionsgeschichte angegeben. Bitte entferne zuletzt diese Warnmarkierung.

Starke Typisierung (englisch 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 mit sehr schwacher Typisierung (z. B. PHP) und solchen mit 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 Unterschiede in der Stärke der Typisierung. Programmiersprachen, die bei dynamischen Variablen nur sehr schwach typisiert sind, wie 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 Zeiger nicht erlaubt sind. Noch stärker typisiert ist wiederum Object Pascal, 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 Gleitkommazahlen.

Verschiedene Definitionen[Bearbeiten | Quelltext bearbeiten]

(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[Bearbeiten | Quelltext bearbeiten]

Vorteile strenger Typisierung sind zum Beispiel[1]

  • 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
  • Durch statische Typumwandlung im Vergleich zu dynamischer Typumwandlung kann sich ein Performance-Gewinn ergeben. In der Regel ist dieser jedoch rein theoretisch und in der Anwendung nicht messbar.

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.
  • Mehr Schreibarbeit und eventuell schlechterer Lesefluss. Es gilt Konfiguration über Konvention.

Realisierung strenger Typisierung in verschiedenen Programmiersprachen[Bearbeiten | Quelltext bearbeiten]

  • C besitzt eine eher schwache Typisierung, da es in sehr vielen Situationen eine implizite oder explizite Umwandlung erlaubt, vor allem im Zusammenhang mit Zeigern. Außerdem unterscheidet C die Datentypen von Wahrheitswerten, Buchstaben und kleinen Zahlen nicht.
  • 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; zum Beispiel dürfen Objektpointer nur dann implizit in einen Zeiger auf ein Objekt der Basisklasse umgewandelt werden, falls die Vererbung public ist. Außerdem dürfen im Gegensatz zu C void-Zeiger nicht in Zeiger 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, Ada oder Visual Basic .NET (mit Option Explicit On) müssen alle Variablen einen Typ besitzen.
  • Perl hat eine relativ schwache Typisierung, so teilen sich Zahlen und Zeichenketten einen Datentyp, der kontextabhängig, je nach benutztem Operator, als Zahl oder Zeichenkette verwendet wird. Nur bei gewünscht strenger Typisierung wird bei eventuell nicht-gewollten Umwandlungen eine Warnung ausgegeben.
  • Python besitzt eine recht starke Typisierung. Beim Umwandeln werden in der Regel explizite Funktionen (str(), int(), usw.) benötigt. Implizite Umwandlungen finden nur selten statt; beim Indizieren von Listen konvertiert False zu 0 und True zu 1, im booleschen Kontext wandeln sich leere Container, Zahlen gleich Null und leere Zeichenketten in False, alles andere in True.
  • Ruby ist stark typisiert. Jedes Objekt hat eine feste Klasse und beim Umwandeln müssen stets explizite Methoden (to_s, to_i, usw.) aufgerufen werden. Lediglich im booleschen Kontext wird implizit konvertiert (nil zu false, alles andere zu true).
  • OCAML und Haskell erlauben keine impliziten Typwandlungen.
  • Visual Basic Classic 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.
  • C#, Modula-2 und Oberon haben strikte Typsysteme, bei denen die Zuweisungskompatibilität sowohl von statischen Typen als auch von dynamischen Typen bereits beim Übersetzen streng geprüft wird.[3][4][5] Nur in speziellen Fällen kann die Zuweisungskompatibilität einer Variable zu einem abweichenden Datentyp im Quellprogramm explizit erzwungen werden. Oberon sieht für Instanzen von dynamischen Datentypen im Quellprogramm explizite Typenwächter (englisch: type guard) vor, die allerdings keine Typenkonversion durchführen, sondern lediglich zur Laufzeit die Zuweisungskompatibilität überwachen.[6]

Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

  1. Christoph-Probst.com: Informelle Methode und Compilertechniken zur Aufdeckung von Programmierfehlern (Memento vom 20. Januar 2010 im Internet Archive) (PDF)
  2. http://rosettacode.org/wiki/Category:Forth
  3. Daniel Larson : Introduction to strongly Typed Data Sets, 25. Januar 2003, abgerufen am 22. März 2016
  4. ETH Oberon White Paper, ETH Zürich, 13. März 2000, abgerufen am 22. März 2016
  5. Massimo Felici, Karama Kanoun, Alberto Pasquini: Computer Safety, Reliability and Security, 18th International Conference, SAFECOMP'99, Toulouse, France, 27. bis 29. September 1999, Proceedings Lecture Notes in Computer Science, Seite 195, Springer, 2003, ISBN 9783540482499
  6. Niklaus Wirth: The Programming Language Oberon, ETH Zürich, 1. Oktober 1990, abgerufen am 22. März 2016