imported>Thoken: /* Realisierung strenger Typisierung in verschiedenen Programmiersprachen */ 2 externe Links geändert; ethoberon.ethz.ch no host anderer Ort, csharp-station.com iabot ok

2025-11-10T20:53:59Z

Realisierung strenger Typisierung in verschiedenen Programmiersprachen: 2 externe Links geändert; ethoberon.ethz.ch no host anderer Ort, csharp-station.com iabot ok

Neue Seite

'''Starke Typisierung''', auch '''strenge Typisierung''' genannt (beide nur teilweise [[Lehnübersetzung|lehnübersetzt]] aus dem [[englische Sprache|englischen]] Ausdruck ''{{lang|en|strong typing}}''), ist ein Prinzip bei der [[Typisierung (Informatik)|Typisierung]] von [[Programmiersprache]]n. 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 [[Statische Typisierung|statischer]] Typisierung zusammen und erweitert diese.

Bei dynamischer Typisierung im Rahmen von [[Zeiger (Informatik)|Referenzvariablen]], [[Vererbung (Programmierung)|Vererbung]] oder [[Polymorphie (Programmierung)|Polymorphie]] – letztere können oft erst zur [[Laufzeit (Informatik)|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 [[Zuweisungskompatibilität|kompatible Zuweisungen]], viele Programmiersprachen tolerieren jedoch aus praktischen Erwägungen implizite Typenumwandlungen ohne oder mit vernachlässigbarem Informationsverlust.

Starke Typisierung wird meist mehr 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 [[Typumwandlung]]en eine Rolle; so ist PHP deshalb schwächer typisiert als C, weil PHP fast überall implizit umwandelt, C jedoch nur bei ähnlichen Typen. C++ ist wiederum deshalb stärker typisiert als C, da z. B. implizite Typumwandlungen von [[Void (Schlüsselwort)|void*]] in beliebige andere [[Zeiger (Informatik)|Zeiger]] nicht erlaubt sind. Noch stärker typisiert ist wiederum [[Object Pascal]], das im Gegensatz zu C++ keine impliziten Umwandlungen zwischen Boolean- und Integer-Werten vornimmt. [[Haskell (Programmiersprache)|Haskell]] und [[Rust (Programmiersprache)|Rust]] erlauben noch nicht einmal implizite Typumwandlungen von Ganz- in Gleitkommazahlen.

== Abstufungen von Typisierung ==

Absteigend, nach Strenge der jeweiligen Typisierung sortiert:

* Es gibt keine Methoden zur Konvertierung einer Variable zu einem anderen Typ. Das Typsystem kann nicht umgangen werden.
* Es sind nur explizite Konvertierungen möglich.
* Typen werden zur Übersetzungszeit überprüft (''statische Typisierung'').
* Typen werden zur Laufzeit überprüft (''dynamische Typisierung'').
* Implizite Konvertierung ist nur zwischen ähnlichen Typen möglich (siehe auch [[Zuweisungskompatibilität]])
* Generelle Unterscheidung zwischen Typen (z. B. hat [[Tcl]] keine verschiedenen Typen)

== Vor- und Nachteile ==

Vorteile strenger Typisierung sind zum Beispiel<ref>{{Webarchiv|url=http://www.christoph-probst.com/uni/presentations/files/20010731-ut/20010731-ut_Ausarbeitung.pdf|wayback=20100120074354|text=Christoph-Probst.com: Informelle Methode und Compilertechniken zur Aufdeckung von Programmierfehlern}} (PDF)</ref>
* 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

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 (Programmierung)|Vererbung von Programmcode]] beziehungsweise durch [[Polymorphie (Programmierung)|Polymorphie]] beispielsweise im Rahmen der [[Generische Programmierung|generischen Programmierung]] nicht nur vermieden, sondern sogar besonders elegant und wohl-strukturiert gelöst werden kann.
* Bei Sprachen ohne [[Typinferenz]] mehr Schreibarbeit und eventuell schlechterer Lesefluss, somit Konfiguration vor Konvention (statt [[Konvention vor Konfiguration]]).

== Realisierung strenger Typisierung in verschiedenen Programmiersprachen ==

* [[C (Programmiersprache)|C]] besitzt eher schwache Typisierung, da es in sehr vielen Situationen implizite oder explizite Umwandlung erlaubt, vor allem im Zusammenhang mit [[Zeiger (Informatik)|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 (Programmiersprache)|Java]], [[C-Sharp|C#]], [[Pascal (Programmiersprache)|Pascal]], [[Ada (Programmiersprache)|Ada]] oder [[Visual Basic .NET]] (mit <code>Option Explicit On</code>) müssen alle Variablen einen Typ besitzen.
* [[Perl (Programmiersprache)|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.
* [[Ruby (Programmiersprache)|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]], [[Haskell (Programmiersprache)|Haskell]] und [[Rust (Programmiersprache)|Rust]]<ref>{{Internetquelle |url=https://doc.rust-lang.org/book/second-edition/ch03-02-data-types.html |titel=Data Types - The Rust Programming Language |zugriff=2018-11-02 |sprache=en}}</ref> erlauben keine impliziten Typwandlungen.
* [[PHP]] erlaubt seit Version 7, innerhalb einzelner Dateien die strenge Typisierung zu aktivieren.<ref>{{Internetquelle |autor= |url=http://php.net/manual/de/functions.arguments.php#functions.arguments.type-declaration.strict |titel=PHP: Funktionsparameter, Unterpunkt „Strenge Typisierung“ - Manual |werk= |hrsg= |datum= |zugriff=2017-12-20 |sprache=de}}</ref>
* [[Visual Basic Classic]] und [[Gambas (Programmiersprache)| Gambas]] besitzen sowohl statisch typisierte Variablen als auch den ''Variant''-Typ, der jegliche Typen enthalten darf.
* [[Assemblersprache]] und [[Forth (Informatik)|Forth]]<ref>{{Internetquelle |url=http://rosettacode.org/wiki/Category:Forth |titel=Category:Forth - Rosetta Code |zugriff=2018-11-02 |sprache=en}}</ref> besitzen keine Typisierung; allein der Programmierer darf/muss die Typüberprüfung erledigen.
* [[C-Sharp|C#]], [[Modula-2]] und [[Oberon (Programmiersprache)|Oberon]] haben strikte Typsysteme, bei denen [[Zuweisungskompatibilität]] sowohl statischer Typen als auch dynamischer Typen bereits beim Übersetzen streng geprüft wird.<ref>Daniel Larson : {{Webarchiv | url=http://www.csharp-station.com/Articles/StronglyTypedDatasets.aspx | wayback=20160325111507 | text=''Introduction to strongly Typed Data Sets''}}, 25. Januar 2003, abgerufen am 22. März 2016</ref><ref>[https://en.wikibooks.org/wiki/Oberon/ETH_Oberon/white ETH Oberon White Paper], ETH Zürich, 13. März 2000, abgerufen am 10. November 2025</ref><ref>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 978-3-540-48249-9</ref> 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.<ref>[[Niklaus Wirth]]: [https://www.inf.ethz.ch/personal/wirth/Oberon/Oberon.Report.pdf ''The Programming Language Oberon''], ETH Zürich, 1. Oktober 1990, abgerufen am 22. März 2016</ref>

== Siehe auch ==
* [[Typisierung (Informatik)]]
* [[Typverletzung]]

== Einzelnachweise ==

<references />

[[Kategorie:Datentyp]]

Starke Typisierung - Versionsgeschichte

imported>Thoken: /* Realisierung strenger Typisierung in verschiedenen Programmiersprachen */ 2 externe Links geändert; ethoberon.ethz.ch no host anderer Ort, csharp-station.com iabot ok