===== Datenstrukturen in C++ =====
Eine Datenstruktur ist ein mathematisches Objekt zur Speicherung von zusammengehörigen Daten. Sie organisiert die Daten und stellt Algorithmen zur Datenverwaltung zur Verfügung. Weil die Daten in einer bestimmten Art und Weise miteinander verknüpft werden, um einen möglichst einfachen Zugang zu ermöglichen, spricht man von einer Struktur.\\
Grundlegende Funktionen einer Datenstruktur sind z.B. das Hinzufügen und das Löschen von Informationen. Dabei muss man natürlich beachten, dass gleiche Funktionen bei verschiedenen Datenstrukturen unterschiedlich effizient und komplex zu programmieren sind. Bestimmte Strukturen benötigen mehr Speicherplatz für die gleichen Daten als andere, bringen dafür aber wiederum Vorteile in anderen Bereichen mit sich. Darum muss man, bevor man sich für eine Datenstruktur entscheidet, deren Vor- und Nachteile kennen und diese in dem jeweiligen konkreten Fall gegeneinander abwägen. Ziel ist es natürlich, durch die geeignete und richtige Wahl einer Struktur Zeit und Speicherplatz zu sparen und möglichst effektiv mit den Daten arbeiten zu können.

==== Arrays ====
Das Array ist die einfachste verwendete Datenstruktur. Es werden hierbei mehrere Variablen vom selben Datentyp gespeichert. Ein Zugriff auf die einzelnen Elemente wird über einen Index möglich.
Grundsätzlich gibt es zwei Typen von Arrays:
  * Arrays konstanter Größe (statische Arrays)
  * Arrays variabler Größe (dynamische Arrays)
Arrays können außerdem bis zu 60 Dimensionen haben, meistens werden aber nicht mehr als drei oder vier gebraucht.

===Eindimensionale Arrays===
Ein eindimensionales Array ist im Grunde eine Kette (Spalte oder auch Zeile) von Elementen mit fortlaufendem Index von 0 beginnend.

  * Deklaration
Für eine Deklaration eines eindimensionalen Arrays wird zuerst der Datentyp, dann der Name des Arrays und zum Schluss die gewünschte Anzahl der Elemente in eckigen Klammern angegeben. Die Anzahl der Elemente muss immer eine Konstante sein und kann weder durch eine Varible festgelegt sein, noch während der Laufzeit geändert werden.\\
Ein Beispiel:
<code cpp>
int k[4];    // erzeugt ein Array vom Datentyp Integer mit Platz für vier Variablen
</code>

  * Wertzuweisung
Um einem bestehenden Array Werte zuzuweisen oder bereits zugewiesene Werte zu ändern, müssen der Arrayname mit dem Index des zu Bearbeitenden Elements in eckigen Klammern und nach einem = der neue Wert dieses Elements eingegeben werden. Der Index des ersten Elements lautet immer 0, daher ist der letzte Index, die bei der Deklaration angegebene Anzahl der Elemente - 1.\\
Fortsetzung des Beispiels:
<code cpp>
k[0]=1;
k[1]=2;
k[2]=3;     // den Elementen werden Werte zugewiesen
k[3]=4;
</code>

  * Wertzuweisung und Ausgabe mithilfe einer for-Schleife
Da es mit zunehmender Anzahl von Elementen immer unpraktischer wird den Elementen einzeln Werte zuzuweisen, kann man mithilfe einer for-Schleife reichlich Zeit und Platz sparen.\\
Wertzuweisung:
<code cpp>
int i[20];    //Deklaration eines eindimensionalen Arrays mit 20 Elementen.
int y=1;

for (int j=0;j<20;j++) 
  {
   i[j]=y;      //Array i wird der Reihe nach mit den Zahlen 1 - 20 gefüllt.
   y++;  
  }
</code> 

Oder:
<code cpp>
int i[20];

for (int j=0;j<20;j++)
  {
   i[j]=StrToInt(InputBox("Wertzuweisung","Wert für das "+IntToStr(j)+". Element:", "");  
  }

</code>

Natürlich können die Werte des Arrays ganz normal mit z.B. i[3] einzeln ausgegeben werden, um den ganzen Array zu durchlaufen und die Werte nacheinander auszugeben kann aber wieder eine for-Schleife zuhilfe genommen werden.\\
Im Beispiel werden die Werte des Arrays in eine Memobox übertragen.
<code cpp>
for (int j=0; j<20; j++)
  {
   Memo1->Lines->Add(i[j]);
  }
</code>

=== Mehrdimensionale Arrays ===
Bei einem mehrdimensionalen Array können Werte nicht nur einer Dimension (Zeile), sondern mehreren übergeben werden. Ein mehrdiemensionales Array ist im Aufbau mit einer Matrix zu vergleichen. Es besitz Spalten und Zeilen durch die die Koordinate des Werts bestimmt wird.

  * Deklaration
Im Allgemeinen ändert sich bei der Deklaration eines mehrdimensionalen Arrays im Gegensatz zu der eines eindimensionalen Arrays nicht viel. Es werden ledigleich mehrere eckige Klammern mit den Anzahlen für Spalten und Zeilen verwendet. 

<code cpp>
int k[3][6];    //Zweidimensionales Array mit 3 Spalten und 6 Zeilen -> 18 Elemente
</code>

  * Wertzuweisung
Wie auch bei einem eindimensionalen Array können Werte einfach über die entsprechenden Indizes geändert werden.
<code cpp>
k[2][3]=5;
k[1][1]=13;
</code>
Da das aber meistens zu zeitaufwändig ist, kann man sich diesmal mit 2 ineinander veschachtelten for-Schleifen helfen:
<code cpp>
for(int i=0; i<3; i++)
  {
   for(int j=0; j<6; j++)
    {
     k[i][j]=StrToInt(InputBox("Wertzuweisung","Wert für das Element der "+IntToStr(i)+". Spalte und "+IntToStr(j)". Zeile:","");
    }
  }
  
</code>

Die Ausgabe kann analog dazu so aussehen:
<code cpp>
for(int i=0; i<3; i++)
  {
   for(int j=0; j<6; j++)
    {
     Memo1->Lines->Add(k[i][j]);
    }
  }
  
</code>

==== Strukturen ====

Oft ist es sinnvoll, nicht nur wie in einem Array Daten desselben Datentyps zusammenzufassen, sondern auch Daten verschiedener Datentypen.

=== struct ===
Eine mit dem Schlüsselwert struct definierte Klasse ist ein Datentyp, der auch als Struktur bezeichnet wird. Die wie Variablen zwischen den geschweiften Klammern aufgeführten Elemente einer solchen Klasse werden auch als Datenelemente bezeichnet. 

Beispiel: Uhrzeit
Die Uhrzeit besteht aus drei Werten: Stunde, Minute und Sekunde. Eine solche Uhrzeit kann durch die Klasse CZeit mit den Datenelementen Stunde, Minute und Sekunde dargestellt werden: 
<code cpp>
struct CZeit
{
 int Stunde;
 int Minute;
 int Sekunde;
};
</code>

Um von diesem neuen Datentyp eine Variable zu erhalten kann man sie wie gewohnt definieren:
<code cpp> 
CZeit t;    //Die Variable t ist vom Datentyp CZeit
</code>

Oder man gibt noch vor dem Semikolon, das die Klassendefinition abschließt eine Variable ein:
<code cpp> 
struct CZeit
{
 int Stunde;
 int Minute;
 int Sekunde;
} t; // Die Variable t ist vom Datentyp CZeit
</code>

Benötigt man nur eine Variable vom neuen Datentyp, muss man keinen Namen dafür angeben:
<code cpp>
struct  // Dieser Datentyp hat keinen eigenen Namen.
{
 int Stunde; 
 int Minute;
 int Sekunde;
} t; // Der Datentyp von t hat keinen Namen
</code>

Natürlich kann man Strukturen auch verschachteln. Wenn man sich eine Tabelle vorstellt, in der sich alle Schüler einer Klasse mit Name, Geburtsdatum, Telefonnummer, usw. eintragen, kann man aus einer Zeile dieser Tabelle auch eine Struktur erstellen:
<code cpp>
struct Schüler
{
 char Name;
 struct 
 {
  int Tag;
  int Monat;
  int Jahr;
 } Geburtsdatum;
 int Telefonnummer;
}s;                       //Die Variable s ist vom Datentyp Schüler
</code>

Man kann die Elemente der vorhin definierten Variable s folgendermaßen ansprechen:
<code cpp>
s.Name;
s.Telefonnummer;
s.Geburtsdatum.Tag;
s.Geburtsdatum.Monat;
</code>

=== class ===
Mit struct können nur Datenelemente zusammengefasst werden. Eine Funktion, die zu einer Klasse gehört, wird als Elementfunktion (Methode) bezeichnet. Mit class können auch Elementfunktionen in eine Klasse eingebunden werden. 

Eine Elementfunktion kann innerhalb oder außerhalb der Klasse definiert werden. Wenn sie außerhalb der Klasse definiert wird, gibt man vor ihrem Namen den Namen der Klasse und den Bereichsoperator „::“ an. Sie muss dann zuvor in der Klasse durch die Angabe ihres Prototyps deklariert werden.

== Konstruktoren ==
Ein Konstruktor ist eine Elementfunktion der Klasse, die dadurch charakterisiert ist, dass sie denselben Namen wie die Klasse hat. Er darf keinen Rückgabetyp haben (auch nicht void). Eine Klasse kann mehrere Konstruktoren haben. Diese müssen sich dann wie alle anderen überladenen Funktionen durch hinreichend verschiedene Parameter unterscheiden. Die Parameter können auch Default-Argumente haben. 
<code cpp>
class Bruch
{
  double zaehler, nenner;
 
  Bruch(double zaehler_)
    { 
    zaehler=zaehler_;
    nenner=1;
    }
 
  Bruch(double zaehler_, double nenner_)
    {
    zaehler=zaehler_;
    nenner=nenner_;
    }
};
</code>

Wenn ich dann eine Variable vom Typ Bruch mit nur einem Parameter definiere, wird der nenner automatisch 1 gesetzt, da ich vermutlich eine ganze Zahl haben wollte.

<code cpp>
Bruch a(2);   // a=2/1
Bruch b(3,2); // b=3/2
</code>

Die beiden Konstruktoren von C2DPunkt können auch durch einen einzigen mit einem Default-Argument ersetzt werden:
<code cpp>
 class Bruch
{
  double zaehler, nenner;
  Bruch(zaehler x_, nenner y_=0)
    {
    zaehler=zaehler_;
    nenner=nenner_;
    }
};
</code>

weitere Datenstrukturen:

    * Zeiger
    * Listen
    * Bäume

-> dynamische Strukturen (Sebastian)