imported>SchlurcherBot: Bot: http → https

2026-04-18T15:34:51Z

Bot: http → https

Neue Seite

{{Begriffsklärungshinweis|Zum internen Aufbau von Dateien siehe [[Dateiformat]]; zu den Regeln zur programmtechnischen Interpretation von Daten siehe [[Datenformat]].}}

Formal bezeichnet ein '''Datentyp''' (vom [[englisch]]en ''{{lang|en|data type}}'') oder eine '''Datenart''' in der [[Informatik]] die Zusammenfassung von Objektmengen mit den darauf definierten [[Operator (Mathematik)|Operationen]]. Dabei werden durch den Datentyp des [[Datensatz]]es unter Verwendung einer sogenannten Signatur ausschließlich die Namen dieser [[Objekt (Programmierung)|Objekt]]- und Operationsmengen [[Spezifikation|spezifiziert]]. Ein so spezifizierter Datentyp besitzt noch keine [[Semantik]].

Die weitaus häufiger verwendete, aber speziellere Bedeutung des Begriffs ''Datentyp'' stammt aus dem Umfeld der [[Programmiersprache]]n und bezeichnet die Zusammenfassung konkreter Wertemengen und darauf definierter Operationen zu einer Einheit. Beispiele für Datentypen sind Ganzzahlen, Kommazahlen, Zeichenketten oder auch komplexere Typen wie Datum/Zeit oder [[Objektorientierte Programmierung|Objekte]]. Zur Unterscheidung wird für diese Datentypen in der Literatur auch der Begriff '''Konkreter Datentyp''' verwendet. Für eine Diskussion, wie Programmiersprachen mit Datentypen umgehen, siehe [[Typisierung (Informatik)|Typisierung]].

Der gedankliche Übergang von der formalen Definition zu der im Umfeld von Programmiersprachen verwendeten Definition konkreter Datentypen geschieht dabei über die sukzessive Einführung einer Semantik zu den formal spezifizierten Namen der Objekt- und Operationsmengen.
Die Konkretisierung der Operationsmenge führt zu [[Abstrakter Datentyp|Abstrakten Datentypen]] beziehungsweise [[Algebraische Struktur|Algebraischen Strukturen]].
Mit der weiteren Konkretisierung der Objektmenge ergibt sich der Konkrete Datentyp.

== Formale Definition eines Datentyps durch eine Signatur ==

Eine Signatur ist ein Paar (Sorten, Operationen), wobei ''Sorten'' Namen für Objektmengen und ''Operationen'' Namen für Operationen auf diesen Mengen repräsentieren. Ein Beispiel soll dies für eine vereinfachte Version des bekannten und weiter unten genauer beschriebenen (konkreten) Datentyp ''Integer'' zeigen, der hier ''Simple Integer'' heiße:

{| style="font-family:monospace"
|colspan="4"|'''Simple Integer'''
|-
| Sorten
|colspan="3"| int
|-
|rowspan="3" style="vertical-align:top"| Operationen
| zero: || || <code>-> int</code>
|-
| + ||: int x int || <code>-> int</code>
|-
| − ||: int x int || <code>-> int</code>
|-
|colspan="4"|'''End Simple Integer'''
|}
Dies ist eine ''Signatur'' für einen angenommenen Datentyp ''Simple Integer'', auf dem nur zwei Operationen + und − (neben der "Erzeuger-Operation") erlaubt sind. Die einzige Sorte nennen wir <code>int</code>. Die Operation ''zero'' dient zur Erzeugung eines <code>int</code>-Elementes. Die Operationen + und − sind jeweils zweistellig und liefern jeweils wiederum ein Element der Sorte <code>int</code>. Wichtig ist, dass es sich hier um eine rein syntaktische Spezifikation handelt. Was ein <code>int</code> ist, wird nirgendwo definiert. Hierzu müsste noch eine Zuordnung des Sortennamens zu einer Menge erfolgen. Eine sinnvolle Zuordnung wäre in diesem Fall etwa die Menge der [[Natürliche Zahlen|natürlichen Zahlen]]. Auch über die Arbeitsweise der Operationen ist nichts weiter ausgesagt als ihre Stelligkeit und ihr Ergebnis. Ob das +-Symbol der Arbeitsweise der Summenoperation entspricht, wird hier nicht festgelegt – dies wäre auch völlig unmöglich, da nicht einmal bekannt ist, ob die Operation auf den natürlichen Zahlen arbeitet. Derartige Zuordnungen fallen in den Bereich der Semantik. Eine um die Semantik erweiterte Spezifikation könnte daher folgendermaßen aussehen:

{| style="font-family:monospace"
|colspan="4"|'''Simple Integer'''
|-
|colspan="4"|/* reine Syntax */
|-
| Sorten || int
|            ||
|-
|rowspan="3" style="vertical-align:top"| Operationen
| zero: || || <code>-> int</code>
|-
| + ||: int x int || <code>-> int</code>
|-
| − ||: int x int || <code>-> int</code>
|-
|colspan="4"|/* Zuordnung einer Semantik */
|-
| Mengen
|colspan="3" | int = IN
|-
|rowspan="3" style="vertical-align:top"| Funktionen
|colspan="3" | zero = 0
|-
| + ||: int x int
|style="font-family:sans-serif"|   entspreche der Summe zweier Zahlen aus IN
|-
| − ||: int x int
|style="font-family:sans-serif"|   entspreche der arithmetischen Differenz zweier Zahlen aus IN
|-
|colspan="4"|'''End Simple Integer'''
|}
Damit wird allerdings der Bereich einer Signatur bereits überschritten. Diese Spezifikation würde man vielmehr als ''Algebra'' bezeichnen. Die Spezifikation kommt auf diese Weise jedoch dem programmiersprachlichen Verständnis des Begriffes ''Datentyp'' näher, dem sich ein Großteil des restlichen Artikels widmet.

== Datentypen in Programmiersprachen ==
[[Datei:Python 3. The standard type hierarchy.png|mini]]
Viele [[Programmiersprache]]n bieten eine eigene Menge an vordefinierten Datentypen, bei denen das Prinzip des jeweiligen Wertebereichs, wie beispielsweise [[Ganze Zahl]]en, [[Gleitkommazahl]]en oder [[Zeichenkette]]n, gleich ist. Die tatsächlichen Namen dieser Datentypen und die genauen Definitionen der Wertebereiche und der dazugehörigen Operationen unterscheiden sich jedoch zum Teil stark, da jene von der verwendeten Programmiersprache, der verwendeten [[Plattform (Computer)|Plattform]] und anderen [[compiler]]abhängigen Faktoren abhängen.

Datentypen werden in der [[Programmierung]] verwendet, um [[Speicherbereich]]en eine konkrete [[Formale Semantik|Semantik]] zuzuweisen. Diese Speicherbereiche werden [[Variable (Programmierung)|Variablen]] oder [[Konstante (Programmierung)|Konstanten]] genannt. Die Datentypen ermöglichen es einem [[Compiler]] oder [[Laufzeitumgebung]], die [[Typisierung (Informatik)|Typverträglichkeit]] der vom [[Programmierer]] angegebenen Operationen zu überprüfen.
Unzulässige Operationen werden zum Teil bereits beim [[Compiler|Kompilieren]] erkannt, so dass beispielsweise die [[Division (Mathematik)|Division]] einer [[Zeichenkette]] ‚HANS’ durch die Zahl ‚5’, was nicht sinnvoll und in üblichen Programmiersprachen undefiniert ist, verhindert wird.

Man unterscheidet elementare und zusammengesetzte Datentypen. Ein weiterer Ordnungsbegriff ist ''Ordinaler Datentyp''.

=== Ordinale Datentypen ===

Ordinale Datentypen sind dadurch gekennzeichnet, dass auf ihnen eine feste [[Ordnungsrelation]] definiert ist, die ihren Werten eine eindeutige Ordnungsnummer zuordnet. Dadurch ist die Reihenfolge der Werte festgelegt. Als Folge hat
* jeder Wert außer dem ersten genau einen direkten Vorgänger und
* jeder Wert außer dem letzten genau einen direkten Nachfolger.

Ob ein elementarer Datentyp auch ein ordinaler Datentyp ist, hängt von der Festlegung in der konkreten Programmiersprache ab.
Beispiele:
* Der ''[[Aufzählungstyp]]'' ist in PASCAL ein ordinaler Datentyp, da die Werte von links nach rechts geordnet sind; Nachfolger, Vorgänger sind über Standardfunktionen bestimmbar. In C ist das nicht der Fall.
* ''Boolean'' ist ein spezieller Aufzählungstyp mit den beiden Werten „falsch“ (Ordnungswert 0) und „wahr“ (Ordnungswert 1), meist englisch „false“ und „true“ genannt.
* ''Ganze Zahlen'' und ''Natürliche Zahlen'' sind von Natur aus ordinale Datentypen.

=== Elementare Datentypen ===

'''Elementare Datentypen''', auch '''einfache Datentypen''' oder '''primitive Datentypen''' genannt, können nur einen Wert des entsprechenden Wertebereichs aufnehmen. Sie besitzen eine festgelegte ([[Endliche Menge|endliche]]) Anzahl von Werten ([[Diskretheit]]). Daher können [[reelle Zahl]]en als [[Gleitkommazahl]]en nur mit einer bestimmten Genauigkeit abgebildet werden. Für elementare Datentypen sind in einer Programmiersprache Grundoperationen definiert, bei den ''Zahlen'' sind das die [[Grundrechenart]]en. Datentypen haben je nach Programmiersprache und Wertebereich unterschiedliche Bezeichnungen und werden groß oder klein geschrieben (hier zur Übersicht alle groß).

==== [[Ganze Zahl]]en ====

* '''Bezeichnung''': BIGINT, BIN, BIN FIXED, BINARY, BYTE, COMP, INT, [[Integer (Datentyp)|INTEGER]], LONG, LONG INT, LONGINT, MEDIUMINT, SHORT, SHORTINT, SMALLINT
* '''Wertebereich:''' Meist 32 Bit (−231…231-1), 8 Bit, 16 Bit, 64 Bit
* '''Operationen:''' [[Grundrechenarten|+, −, *]], [[Vergleichsoperator|<, >, =]], [[Division mit Rest|Ganzzahldivision]], [[Modulo]], [[Bitweiser Operator|bitweise Operatoren]], [[Inkrement und Dekrement]]

==== [[Natürliche Zahl]]en ====

* '''Bezeichnung''': BYTE, CARDINAL, DWORD, NATURAL, UINT, UNSIGNED, UNSIGNED CHAR, UNSIGNED INT, UNSIGNED LONG, UNSIGNED SHORT, [[Datenwort|WORD]]
* '''Wertebereich:''' Meist 32 Bit (0…232-1), 8 Bit, 16 Bit, 64 Bit
* '''Operationen:''' [[Grundrechenarten|+, −, *]], [[Vergleichsoperator|<, >, =]], [[Division mit Rest|Ganzzahldivision]], [[Modulo]], [[Bitweiser Operator|bitweise Operatoren]]

==== [[Festkommazahl]]en (Dezimalzahlen) ====

* '''Bezeichnung:''' COMP-3, CURRENCY, PACKED DECIMAL, DEC, DECIMAL, MONEY, NUMERIC
* '''Wertebereich:''' Wertebereich direkt abhängig von der maximalen Stellenanzahl, die meist vorzugeben ist; CURRENCY (64 Bit): -922337203685477,5808…922337203685477,5807
* '''Operationen:''' [[Grundrechenarten|+, −, *]], [[Vergleichsoperator|<, >, =]], [[Division mit Rest|Ganzzahldivision]], [[Modulo]]

==== [[Aufzählungstyp]]en ====

* '''Bezeichnung:''' ENUM, SET oder implizit
* '''Wertebereich:''' Frei wählbar, beispielsweise ''(SCHWARZ, ROT, BLAU, GELB)''
* '''Operationen:''' [[Vergleichsoperator|<, >, =]]

==== [[Boolean]] (logische Werte) ====

* '''Bezeichnung:''' BOOL, BOOLEAN, LOGICAL, oder (implizit ohne Bezeichner)
* '''Wertebereich:''' (TRUE, FALSE) oder (≠ 0, = 0) oder (= -1, = 0)
* '''Operationen:''' [[Negation|NOT]], [[Konjunktion (Logik)|AND]], [[XOR]], [[NOR-Gatter|NOR]], [[Shefferscher Strich|NAND]], [[Disjunktion|OR]], [[Vergleichsoperator|=, ≠]]

==== [[Zeichen]] (einzelnes Zeichen) ====

* '''Bezeichnung:''' [[Char (Datentyp)|CHAR]], CHARACTER
* '''Wertebereich:''' Alle Elemente des [[Zeichensatz]]es (zum Beispiel Buchstaben)
* '''Operationen:''' [[Vergleichsoperator|<, >, =]], Konvertierung in INTEGER…
Durch die weite Verbreitung von [[MBCS]] entspricht CHAR meist nicht mehr einem Element eines Zeichen''satzes'' (und somit einem Zeichen), sondern einer „(Code-)Einheit“ einer Zeichen''kodierung''. In den verbreiteten MBCS [[UTF-8]] und [[UTF-16]] ist zwar jeweils eine Minderheit der [[Unicode|damit insgesamt kodierbaren Zeichen]] mit einem einzelnen CHAR kodierbar, die Mehrheit benötigt jedoch eine Folge mehrerer CHARs: In UTF-8 bilden dann zwei bis vier 8-Bit-Einheiten eine ''Sequenz'', in UTF-16 zwei 16-Bit-Einheiten ein ''Surrogate-Pärchen''. Erst wenn man diese Einheiten hintereinander in eine Zeichenkette schreibt, ist das Zeichen kodiert. CHAR ist somit allgemein eher als ein 8- (ANSICHAR, BYTECHAR) oder 16-Bit-Wert (WIDECHAR, NATIONAL CHAR) zu verstehen, der bei Zeichenkettenoperationen nicht als Zahl, sondern als eine Zeichenkette der Länge 1 interpretiert wird.

==== [[Gleitkommazahl]]en ====

* '''Bezeichnung:''' DOUBLE, DOUBLE PRECISION, EXTENDED, FLOAT, HALF, LONGREAL, REAL, SINGLE, SHORTREAL
* '''Wertebereich:''' Verschiedene Definitionen (siehe unten)
* '''Operationen:''' [[Grundrechenarten|+, −, *, /]], [[Vergleichsoperator|<, >, =]]

{| class="wikitable"
|+ Genauigkeit von Gleitkommazahl-Typen 
! !! Bitanzahl n
! colspan="2"| Wertebereich von … bis !! signifikante Stellen
|-
| HALF || 16 || 3,1·10−5 || 6,6·104 || 4
|-
| SINGLE, REAL || 32 || 1,5·10−45 || 3,4·1038 || 7–8
|-
| REAL || 48 || 2,9·10−39 || 1,7·1038 || 11–12
|-
| DOUBLE, REAL || 64 || 5,0·10−324 || 1,7·10308 || 15–16
|-
| REAL || 64 || 1,1·10−306 || 1,8·10308 || 15–16
|-
| EXTENDED || 80 || 1,9·10−4951 || 1,1·104932 || 19–20
|}

==== Bitmengen ====

Bitmengen stellen eine [[Menge (Datenstruktur)|Menge]] von mehreren [[Bit]]s dar. In einigen Programmiersprachen gibt es zur Wahrung der [[Typsicherheit]] einen eigenen Datentyp und eigene [[Operator (Mathematik)|Operatoren]] (zum Beispiel für die [[Vereinigungsmenge]] oder die [[Schnittmenge]]) für Bitmengen.

Bitmengen sind nicht mit [[Aufzählungstyp]]en oder [[Datenfeld]]ern zu verwechseln, da mehrere Elemente des Datentyps (respektive der Menge) gleichzeitig angesprochen werden können. In vielen Programmiersprachen werden [[Ganze Zahl|ganzzahlige]] Datentypen für die Repräsentation von Bitmengen benutzt, so dass Zahlen und Bitmengen [[Zuweisungskompatibilität|zuweisungskompatibel]] sind, obwohl [[Arithmetik|arithmetische]] Operatoren bei Bitmengen und [[Menge (Mathematik)|Mengenoperatoren]] im Zusammenhang mit ganzen Zahlen keinen Sinn ergeben.

* '''Bezeichnung:''' [[Menge (Datenstruktur)|SET]], BITSET
* '''Wertebereich:''' {} für leere Menge, {i} für Menge mit dem Element i, {i, j} für Menge mit den Elementen i und j
* '''Operationen:''' [[Vergleichsoperator]], Typumwandlung in ganze Zahl oder Element eines [[Zeichensatz]]es, Mengenoperatoren

=== Zeigertypen / Dynamische Datentypen ===

Eine Besonderheit sind [[Zeiger (Informatik)|Zeiger]], deren wirklicher Wertebereich in vielen Programmiersprachen anonym bleibt, da sie „nur“ Referenzen auf beliebige andere Datentypen sind. Je nach referenziertem Typ werden Zeiger auf bestimmte Elemente gesondert benannt, wie beispielsweise Zeiger auf [[Datei]]en, [[Drucker (Gerät)|Drucker]] oder [[Pipe (Informatik)|Pipes]].

[[Objektorientierte Programmiersprache]]n speichern den vom Zeiger referenzierten Datentyp (zum Beispiel bei Instanzvariablen) zusammen mit der Adresse, auf die der Zeiger verweist, damit die [[Zuweisungskompatibilität]] nicht nur für den Datentyp der Adressierung, sondern auch für den referenzierten Inhalt geprüft werden kann. Dies ist dann sogar zur [[Laufzeit (Informatik)|Laufzeit]] möglich und für einige Anwendungen (beispielsweise bei [[Polymorphie (Programmierung)|Polymorphie]]) auch notwendig.

==== [[Zeiger (Informatik)|Zeiger]] ====

* '''Bezeichnung:''' ACCESS, POINTER, IntPtr oder auch nur kurz Stern (<code>*</code>)
* '''Wertebereich:''' Adresse des Basistyps (oft anonym)
* '''Operationen:''' Referenz, Dereferenz, in einigen Sprachen: [[Grundrechenarten|+, −, *, /]]

==== Konstanter Nullzeiger ====

* '''Bezeichnung:''' NULL, VOID, None, NIL, Nothing
* '''Wertebereich:''' keiner
* '''Operationen''': [[Vergleichsoperator|=]]
* '''Bedeutung:''' Dieser Zeiger ist verschieden von allen Zeigern auf Objekte.

==== Prozedurtypen ====

Einige Programmiersprachen, wie zum Beispiel [[Oberon (Programmiersprache)|Oberon]], verwenden Prozedurtypen, die für Zeigervariablen verwendet werden, die auf verschiedene Prozeduren mit identischen formalen [[Parameter (Informatik)|Parameterlisten]] zeigen können.

=== Zusammengesetzte Datentypen ===

Zusammengesetzte Datentypen sind ein Datenkonstrukt, welches aus einfacheren Datentypen besteht. Da sie theoretisch beliebig komplex werden können, werden sie auch häufig schon zu den [[Datenstruktur]]en gezählt. Den meisten Programmiersprachen gemeinsam sind:

* Reihung ([[Tupel (Informatik)|Tupel]]), Tabelle; Feld (mehrdeutig!)
** '''Bezeichnung''': [[Array (Datentyp)|ARRAY]] (implizite Definition mit [n] oder (n) ohne Bezeichner)
** '''Wertebereich:''' Abbildung einer endlichen Menge (Indexmenge) auf den Wertebereich eines Basistyps (Elementtyp). Die Indexmenge muss dabei ordinal sein. Durch Anwenden mehrerer Indizes entsteht eine mehrdimensionale Reihung.
** '''Operationen:''' [[Vergleichsoperator|<, >, =]], Zuweisung mit [[Zuweisungskompatibilität]]
** '''Beispiel:''' <code>type 3D-Vektor is ARRAY(1..3) of INTEGER;</code>
* [[Zeichenkette]] fester Länge (im Grunde sind Zeichenketten selbst nur eine Reihung des Typs Character (Zeichen). Da sie jedoch in vielen Programmiersprachen vordefiniert sind, werden sie hier gesondert aufgelistet.)
** '''Bezeichnung''': [[Array (Datentyp)|Array]] of CHAR, CHAR(n), CHAR[n]
** '''Wertebereich:''' Alle möglichen Zeichenketten
** '''Operationen:''' Stringfunktionen (Teilstring, [[Konkatenation (Listen)|Konkatenation]] [Zusammensetzung]), [[Vergleichsoperator|<, >, =]]
* [[Zeichenkette]] variabler Länge. Die Länge ist feststellbar, implizit durch ein Metazeichen als String-Endezeichen (ASCII \0), explizit durch eine Variable, oder über eine Standardfunktion. Häufig als [[Abstrakter Datentyp]] in einer Standardbibliothek.
** '''Bezeichnung''': [[Zeichenkette|String]], [[Array (Datentyp)|Array]] of CHAR, VARCHAR, [[CLOB]], Text
** '''Wertebereich:''' Zeichenketten variabler Länge
** '''Operationen:''' Stringfunktionen (Teilstring, Länge, Konkatenation [Zusammensetzung]), [[Vergleichsoperator|<, >, =]]
* binäre [[Zeichenkette]] variabler Länge. Die Länge kann durch eine Variable oder über eine Standardfunktion ermittelt werden.<ref>{{Internetquelle |autor=David Axmark, Michael „Monty“ Widenius u. a. |url=http://dev.mysql.com/doc/refman/5.1/de/blob.html |titel=Die Spaltentypen BLOB und TEXT |werk=MySQL 5.1 Referenzhandbuch |hrsg=MySQL AB |datum=2008-08-11 |abruf=2008-08-28 |archiv-url=https://web.archive.org/web/20080718111506/http://dev.mysql.com/doc/refman/5.1/de/blob.html |archiv-datum=2008-07-18|offline=1}}</ref><ref>{{Internetquelle |autor=Jack Melnick u. a. |url=https://download.oracle.com/docs/cd/B28359_01/appdev.111/b28395/oci07lob.htm |titel=LOB and BFILE Operations |werk=Oracle Call Interface Programmer’s Guide, 11g Release 1 (11.1) |hrsg=Oracle |datum=2008-05 |sprache=en |abruf=2008-08-28}}</ref>
** '''Bezeichnung''': [[Binary Large Object|BLOB]]
** '''Wertebereich:''' binäre Zeichenketten variabler Länge
** '''Operationen:''' Länge, Konkatenation [Zusammensetzung], [[Vergleichsoperator|=]]
* [[Verbund (Datentyp)|Verbund]], Satz, Struktur, Bereich
** '''Bezeichnung''': RECORD, STRUCT, CLASS (erweiterte Bedeutung), (implizite Definition über Stufennummern)
** '''Wertebereich:''' Ein Verbund enthält eine Folge verschiedener Komponenten, welche verschiedene Datentypen haben können. Als Komponententyp ist jeder Typ zulässig. In einigen [[Objektorientierte Programmiersprache|objektorientierten Programmiersprachen]] (zum Beispiel [[Oberon (Programmiersprache)|Oberon]]) können Verbunde zur Beschreibung des Verhaltens der Komponenten des Verbunds mittels [[Methode (Programmierung)|Methoden]] auch typengebundene Prozeduren haben.
** '''Operationen:''' Vergleich (nur Gleichheit oder Verschiedenheit), Zuweisung mit oder ohne [[Zuweisungskompatibilität]] (stark programmiersprachenabhängig)
** '''Beispiel:''' <code>type Prüfung is RECORD (Fach: STRING, Schueler: STRING, Punkte: INTEGER, Lehrer: STRING, Termin: DATUM)</code>
** In vielen Programmiersprachen existieren Möglichkeiten, den [[Speicherbereich]] eines Verbunds mehrfach unterschiedlich zu interpretieren. Das wird ''Variantenrecord'' oder ''UNION'' genannt. Dabei ist jedoch meist keine [[Typsicherheit]] mehr gegeben.

=== Zusätzliche individuelle Formatangaben ===
Bei der Verwendung von Datentypen im Quelltext eines Programms werden oft zu einem gewählten Datentyp individuelle und zusätzliche Formatangaben implementiert. Zum Beispiel kann ein ''Datum'' (oder allgemein eine Zeitangabe) als ganzzahliger elementarer Datentyp angelegt werden, zu dem Angaben zur Form der Verarbeitung/Darstellung ergänzt werden. Das Datum ist dann z. B. in Millisekunden seit dem 1. Januar 1970 0:00 Uhr gespeichert und kann, davon ausgehend, in bestimmte andere Formen (wie 'TT.MM.JJJJ' oder 'MM.TT hh:ss') überführt werden; siehe.<ref>C-Standard ISO/IEC 9899:TC3 ''Committee Draft'' [https://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf open-std.org] (PDF; 3,6 MB) S. 338</ref> Verbreitet ist auch eine je nach Kontext unterschiedlich definierte [[julianisches Datum#Zeitmaße in Software|Variante des julianischen Datums]], also eine Gleitkommazahl, deren Ganzzahlanteil die Anzahl der Tage ab einem bestimmten Zeitpunkt angibt und der Nachkommateil den vergangenen Teil des kodierten Tages (also die Uhrzeit). Alternativ könnte ein Datum natürlich auch als Verbund (z. B. aus drei Zahlen für Tag, Monat und Jahr) dargestellt werden.

== Funktionen als Werte erster Ordnung ==

In vielen zeitgenössischen Programmiersprachen sind neben ''Funktionszeigern'' auch reguläre Funktionswerte, Funktionsliterale bzw. [[anonyme Funktion]]en verfügbar. Diese wurden in Anlehnung an den [[Lambda-Kalkül]] entwickelt und bereits 1958 (wenn auch mit fehlerhafter dynamischer Bindung) in LISP implementiert. Eine korrekte, d. h. statische Bindung wurde z. B. für [[Algol 68]] spezifiziert. Dass Funktionen bis heute z. T. nicht als Werte begriffen werden, liegt an der erst jetzt überhaupt einsetzenden Verbreitung dieser Konzeption außerhalb der Informatik.

== Universeller Datentyp ==

Unter einem universellen Datentyp wird der Typ der Werte in einer Programmiersprache mit Unterstützung für typenlose Variablen verstanden. Hierbei handelt es sich meist um die [[Disjunkte Vereinigung|diskriminierte Vereinigung]] der Typen der auftretenden Werte (elementare, zusammengesetzte, Funktionen etc.). Der universelle Datentyp tritt charakteristischerweise in universellen [[Skriptsprache]]n auf. Als Beispiele für die Verwendung von universellen Datentypen in Sprachen anderer Gattung sei der [[Lambda-Kalkül]], in dem Funktionen die einzigen Werte sind, und [[Prolog (Programmiersprache)|Prolog]] hervorgehoben, in der die Daten durch die [[Herbrand-Struktur]] gegeben sind.

== Abstrakte Datentypen ==
{{Hauptartikel|Abstrakter Datentyp}}

; Definition:Ein Abstrakter Datentyp (ADT) ist eine Sammlung von Daten in Variablen – verbunden mit der Definition aller Operationen, die auf sie zugreifen.

Da der Zugriff (lesend oder schreibend) nur über die festgelegten Operationen erfolgt, sind die Daten nach außen [[Datenkapselung (Programmierung)|gekapselt]]. Jeder ADT enthält einen Datentyp bzw. eine Datenstruktur.

[[Objektorientierte Programmiersprache]]n unterstützen durch ihr Klassenkonzept die Erstellung von ADTs, da hier Daten und Operationen ''gebunden'' werden, und die Daten geschützt werden können. Einige [[Modulare Programmierung|modulare Programmiersprachen]] wie [[Ada (Programmiersprache)|Ada]] oder [[Modula-2]] unterstützen ebenfalls gezielt die Erstellung von abstrakten Datentypen.

Aus fachlicher Sicht definiert ein [[Abstrakter Datentyp]] einen definierten Wertebereich mit fachlicher Bedeutung und seinen spezifischen Ausprägungen. So ist der Datentyp 'Kundennummer' möglicherweise vom Elementartyp 'Ganze Zahlen', unterscheidet sich jedoch durch eine definierte Länge und z. B. einer Prüfziffer in der letzten Stelle. – Es bildet dadurch eine Untermenge aller ganzen Zahlen in der definierten Länge. Es können hier auch komplexe Daten mit einer Abhängigkeit zueinander als ADT vereint werden. Dies ist am Beispiel einer Darstellung von Zeiträumen gebräuchlich. Es werden ein Beginndatum und ein Endedatum (beide haben den Datentyp 'Date') über eine Integritätsbedingung verknüpft. Dadurch wird letztlich der zulässige Wertebereich des Endedatums an weitere Bedingungen geknüpft. – Letztendlich ist ein ADT ein beliebig komplexer Wertebereich, der an statische und/oder dynamische Werte und zugeordnete Regeln zur Wertbestimmung gebunden ist.

== Anonyme Datentypen ==

Einige Programmiersprachen und die XML-Strukturdefinitionssprache [[XML Schema]] unterstützen das Konzept des [[Anonymer Datentyp|anonymen Datentyps]]. Dabei handelt es sich um einen Datentyp, für den kein Name definiert wird.

== Polymorphie von Datentypen ==
{{Siehe auch|Polymorphie (Programmierung)}}
Die parametrische [[Polymorphie (Programmierung)|Polymorphie]] ermöglicht es, einen Datentyp (oder eine [[Funktion (Programmierung)|Funktion]]) [[Generische Programmierung|generisch]] zu schreiben, so dass er Werte einheitlich behandeln kann, ohne von seinem konkreten statischen Datentyp abhängig zu sein. Die parametrische Polymorphie ist eine Möglichkeit, eine [[Programmiersprache]] ausdrucksstärker zu machen und gleichzeitig die vollständige statische [[Typsicherheit]] zu gewährleisten.

Ein Datentyp, der den Anschein erwecken kann, von einem verallgemeinerten Datentyp zu sein, z. B. eine Liste mit Elementen beliebigen Typs, wird als ''polymorpher Datentyp'' bezeichnet.

== Generische Programmierung ==
{{Siehe auch|Generische Programmierung}}
Die Implementierung erfolgt bei einigen [[Programmiersprache]]n durch das Konzept [[Generischer Typ|generischer Typen]] bzw. [[Template (C++)|Templates]] – so gestalten sich [[Dynamische Programmiersprache|dynamische Programmiersprachen]], bei denen sich der Typ einer Variable zur Laufzeit ändern darf, durch ihre verallgemeinerte [[Polymorphie (Programmierung)|Polymorphie]] generisch. Von Sprachen, die solche Mechanismen bieten, sagt man auch, dass sie [[generische Programmierung]] erlauben.

Wesentlich bei der generischen Programmierung ist, dass die Algorithmen nicht für einen bestimmten Datentyp geschrieben werden, sondern nur bestimmte Anforderungen an die Typen stellen. Das Prinzip wird auch ''parametrische Polymorphie'' genannt.

Paradebeispiel ist die [[C++-Standardbibliothek]] der Programmiersprache [[C++]], bei der die [[Algorithmus|Algorithmen]] so weit wie möglich von den Datenstrukturen, mit denen sie arbeiten, getrennt werden.

== Weblinks ==
{{commonscat|Data types}}
{{Wiktionary}}
'''Java'''
* [https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html Java Tutorial, Primitive Data Types]
'''SQL'''
* [https://www.postgresql.org/docs/8.3/static/datatype.html Beschreibung der Datentypen] in [[PostgreSQL]] mit Hinweisen auf Standardkonformität nach [[American National Standards Institute|ANSI]]/[[Internationale Organisation für Normung|ISO]] (englisch)
* [http://dev.mysql.com/doc/refman/5.1/de/data-types.html Kapitel 11. Datentypen] im Referenzhandbuch von [[MySQL]] 5.1
'''Ada'''
* [http://oopweb.com/Ada/Documents/Lovelace/Volume/lesson6.htm oopweb.com]

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4011149-0}}

[[Kategorie:Datentyp| ]]
[[Kategorie:Programmiersprachelement]]
[[Kategorie:Datenstruktur]]

Datentyp - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https