Im letzten Beitrag habe ich erklärt, wie moderne Programmiersprachen grundlegend aufgebaut sind und durch welche Strukturen sie als Aufsatz auf Assembler das Programmieren erleichtern können. Beim Hantieren mit den Variablen im Beitrag sollte aufgefallen sein, dass ich stillschweigend und implizit davon ausgegangen bin, dass jede Variable eine ganze Zahl repräsentiert. Für die Grundlagen reicht das, bei komplexeren Programmen benötigt man jedoch einen etwas differenzierteren Mechanismus – und um den soll es heute gehen.
Bisher haben wir bereits betrachtet, wie Computer mit natürlichen, ganzen und reellen Zahlen rechnen können. In der Mathematik stellen diese Zahlenbereiche Mengen dar, also Sammlungen von Elementen, wobei eine Variable einem beliebigen Wert aus so einer Menge entsprechen kann. In der Informatik bezeichnet man eine solche Menge als Datentyp und die Elemente der Menge als Objekte (eine 1 ist also ein Objekt – seltsam, aber wahr). Mathematisch gesehen sind die Mengen der natürlichen, ganzen und reellen Zahlen zwar unendlich groß, aber auf Grund der Darstellung im Computer als Bitkette haben wir in der Informatik wie bereits besprochen einen begrenzten Zahlenraum.
Nun kann man mit Bitketten natürlich noch viel mehr als einfache Zahlen darstellen. Das erste, was jedem auffällt, der zum Beispiel diesen Artikel hier liest, ist, dass Computer augenscheinlich doch mehr als Zahlen speichern können, mindestens nämlich noch Buchstaben. Neben den Zahlen haben wir also einen weiteren Datentyp: Buchstaben oder Schriftzeichen, im englischen als Characters bezeichnet. Die Darstellung ist hier ziemlich einfach: eine Folge von zumeist 8 Bit (1 Byte) wird als ein konkretes Zeichen interpretiert, wobei die Interpretation meist dem sogenannten ASCII-Standard folgt (der eigentlich nur 7 Bit verwendet). So entspricht etwa die Bitkette 010000112 = 6710 dem großen C; mit 7 Bit können 128 Zeichen dargestellt werden, was für das lateinische Alphabet in Groß- und Kleinschreibung, die Zahlen, Operatoren und einige Sonderzeichen wie Zeilenende und ähnliches locker ausreicht (wer sich jetzt fragt, wie damit zum Beispiel das chinesische Alphabet abgebildet wird, der möge sich über Unicode informieren – vielleicht mache ich aber dazu auch noch irgendwann einmal einen Beitrag).
Nur allein mit Zeichen kommt man natürlich nicht weit: man muss sie auch zu Wörtern und Sätzen, sogenannten Zeichenketten oder englisch Strings, verbinden können. Auch das ist nicht kompliziert, wenn im Speicher einfach mehrere Bytes hintereinander angeordnet werden. Zusätzlich muss dem Computer nun natürlich noch mitgeteilt werden, wie lang die Zeichenkette ist – das geschieht entweder über die Angabe der Länge als natürliche Zahl vor der Bitkette im Speicher oder durch die Verwendung eines besonderen Abschluss-Bytes am Ende der Bitkette.
Nun fehlt eigentlich nur noch ein wichtiger Datentyp, und zwar der elementarste von allen; ich habe ihn bisher bereits in praktisch jedem Artikel verwendet, ohne ihn explizit zu erwähnen: die Wahrheitswerte. Dieser Datentyp umfasst die beiden Werte wahr (engl. true) und false (engl. false) und ist, wie wir bereits gesehen haben, für das Rechnen im Computer elementar; aber auch beim Programmieren wird er benötigt, zum Beispiel als Wert einer Bedingung in einer Schleife oder Verzweigung; in der Informatik werden Werte dieses Datentyps oft als boolesche Werte bezeichnet (nach dem Mathematiker George Boole, einem englischen Mathemiker und dem Erfinder des ersten Logikkalküls).
Hier noch einmal eine Übersicht über alle bisher genannten Datentypen:
| Datentyp | Bezeichnung in der Informatik |
|---|---|
| natürliche Zahlen | Natural (N) |
| ganze Zahlen | Integer (Z) |
| Gleitkommazahlen | Real (R) |
| Zeichen | Character (Char) |
| Zeichenketten | String (S) |
| Wahrheitswerte | Boolean (B) |
Nun kann man schon allein mit diesen Datentypen recht viele Dinge machen, da sie die Grundlage für jegliche Operation bilden – man spricht daher auch von primitiven Datentypen. Zur Lösung komplexerer Probleme benötigt man jedoch immer noch ein paar Typen zusätzlich, um sie vernünftig lösen zu können. Und hier kommen die zusammengesetzten Datentypen ins Spiel; wie ihr Name schon sagt, setzen sie sich aus anderen Datentypen (entweder primitive oder selbst zusammengesetzte) zusammen. Zwei dieser Strukturen werden besonders häufig verwendet: das Feld (englisch Array) und der Verbund (häufig als Record oder Structure bezeichnet).
Ein Feld ist eine Sammlung gleichartiger Datentypen, so wie etwa Tupel und Vektoren in der Mathematik, wobei die Menge der in der Sammlung vorhandenen Daten in der Regel vorgegeben ist (ist sie es nicht, spricht man von dynamischen Arrays) und jedes einzelne Element der Sammlung über einen Index identifizierbar ist (ganz so, wie wir es aus der Mathematik kennen, wenn wir xi für das i-te Element im Tupel x schreiben). Wollen wir also etwa 10 natürliche Zahlen speichern, so benötigen wir ein Feld von natürlichen Zahlen der Länge 10 (der Mathematiker würde von einem 10-Tupel natürlicher Zahlen sprechen); die einzelnen Zahlen im Feld sind über ihren Index identifizierbar, wobei der Index je nach verwendeter Programmiersprache von 0 bis 9 oder von 1 bis 10 reicht. In der Informatik hat es sich eingebürgert, den Zugriff auf das i-te Element eines Tupels x mit Hilfe eckiger Klammern zu schreiben, etwa so
(das entspricht genau dem xi aus der Mathematik):
x[i]
Bei der Notation des Feld-Datentyps an sich möchte ich mich im weiteren an der Vektor-Schreibweise der Mathematik orientieren; ein Feld von 10 natürlichen Zahlen würde also mit N10 beschrieben werden.
Ein Datenverbund ist einem Feld ähnlich, nur dass die einzelnen Bestandteile nicht notwendigerweise den gleichen Datentyp haben müssen; somit können auch komplexere Strukturen beschrieben werden, wie sie in der Informatik häufig vorkommen. Zusätzlich ist es möglich, den einzelnen Bestandteilen eines Verbundes explizite Namen zu geben, so dass sie nicht über ihren Index angesprochen werden müssen (was in vielen modernen Programmiersprachen auch gar nicht mehr geht). Zusätzlich kann der gesamte Verbund noch einen Namen bekommen, damit er im Programm an mehreren Stellen benutzt werden kann. Nehmen wir zum Beispiel an, dass wir für einen Algorithmus ein regelmäßiges n-Eck, also ein Polygon, beschreiben wollen. Dieses besteht aus zwei Informationen: der Anzahl der Ecken v (vertices, eine natürliche Zahl) und der Kantenlänge e (edge length, eine reelle Zahl). Wir können also etwa schreiben:
type Polygon:
v ∈ N
e ∈ R
Liegt ein Objekt eines solchen Datentyps vor, ist es in der Informatik üblich, auf die einzelnen Bestandteile des Objektes über den sogenannten Punkt-Operator zuzugreifen. Haben wir also ein Polygon p, so können wir seine Kantenlänge abfragen über den Code:
p.e
Jetzt hat man bei der Definition des Datentyps Polygon schon eine Besonderheit gesehen: ich habe den einzelnen Bestandteilen einen konkreten Datentyp vorgegeben; beim bisherigen Code habe ich das nicht gemacht. Im Grunde ist es möglich, den Typ einer Variablen (und eines Datentyp-Bestandteils) nicht weiter zu spezifizieren; in der Tat wird das sogar in vielen Programmiersprachen so gemacht (in erster Linie in den sogenannten Scriptsprachen). Der Nachteil dieser Vorgehensweise ist natürlich, dass insbesondere Fremdcode so schlechter gelesen werden kann, da erst herausgefunden werden muss, was eine bestimmte Variable genau repräsentiert. Hinzu kommt aber noch ein ganz pragmatischer Nachteil: an irgendeiner Stelle muss dem Computer ja mitgeteilt werden, welche Rechenoperation er zum Beispiel für zwei Variablen wählen soll. Wie wir wissen, werden etwa ganze und reelle Zahlen unterschiedlich addiert; wenn beim Schreiben eines Programms noch nicht bekannt ist, von welchem Datentyp eine Variable ist, so muss dieser zur Laufzeit bestimmt werden, was Rechenzeit und Speicherplatz kostet. Aus diesem Grund wird der Datentyp einer Variablen häufig spezifiziert. Das kann implizit geschehen (zum Beispiel kann bei der ersten Zuweisung an eine Variable im Programmcode der Datentyp bestimmt werden) oder explizit, indem man den gewünschten Typ hinschreibt, die Variable also deklariert. Das kann zum Beispiel für verschiedene Variablen in etwa so aussehen, ganz, wie aus der Mathematik bekannt (und diese Notation werde ich auch weiterhin benutzen):
var1 ∈ N
var2 ∈ Z8
var3 ∈ Polygon
Damit haben wir jetzt fast alles an Rüstzeug zusammen, um uns den eigentlich spannenden Themen der Informatik zu zuwenden: den Algorithmen und Datenstrukturen. In den folgenden Artikeln werde ich mich diesem Themengebiet widmen, wobei ich jedoch auch immer hie und da einen Exkurs in die Theorie der Programmiersprachen wagen werde. Wenn bestimmte Themen gewünscht werden, schreibt sie einfach in die Kommentare oder mir eine Mail – wenn sie nicht zu kompliziert sind, werde ich gerne einen Artikel dazu schreiben.
Kommentare (7)