Von Null auf C++ auf unter 40 Seiten

• Abfragen und Schleifen
• Arrays
• Funktionen
• Klassen
• Templates

Wenn Sie gern schnell ins Thema einsteigen wollen oder wenn Sie schon Vorkenntnisse haben, dann ist dieses Kapitel für Sie. Hier geht es im scharfen Tempo einmal quer durch C++. Wenn Sie besser lernen, indem Sie ordentlich Stein auf Stein legen, überschlagen Sie dieses Kapitel!

Dieses Kapitel hat etwas vom Wilden Westen: Erst wird geschossen, dann wird erklärt. Hier wird anhand einiger Beispielprogramme erläutert, wie Sie in C++ programmieren können. Die Details werden in den späteren Kapiteln ausführlich besprochen. Dazu finden Sie an den entsprechenden Stellen Hinweise auf die ausführlicheren Abschnitte. Wenn Ihnen diese Art des Lernens nicht so liegt, dann können Sie dieses Kapitel problemlos überschlagen. Es geht im zweiten Kapitel noch einmal von vorn los, dann aber sehr viel detaillierter und ruhiger.

Um alles so schön zu komprimieren, mussten natürlich ein paar Details geopfert werden. Auch sind einige Beschreibungen eher anschaulich als wissenschaftlich exakt. Dafür wissen Sie nach dem ersten Kapitel schon einmal, wo es ungefähr lang gehen wird. Selbst wenn Sie also nach dem Lesen dieses Kapitels etwas verwirrt sein sollten, haben Sie immerhin schon einen guten Überblick. Und das hat ja auch seinen Wert.

Ein Programm

Das erste Programm enthält bereits eine ganze Menge Aktivitäten. Es gibt eine Meldung auf dem Bildschirm aus, fordert eine Zahleneingabe, errechnet das Quadrat hieraus und gibt das Ergebnis auf dem Bildschirm aus. Nur Geschirrspülen kann es nicht.

#include <iostream>
using namespace std;

int main()
{
    int Eingabe;
    int Quadrat;
    cout << "Geben Sie eine Zahl ein: ";
    cin >> Eingabe;
    Quadrat = Eingabe * Eingabe;
    cout << "Die Quadratzahl lautet " << Quadrat << endl;
}

Übersetzen

> c++ erst.cpp
>

Der Compiler jammert nicht, also ist er zufrieden. Nach der erfolgreichen Kompilierung kann das Programm gestartet werden. Wenn Sie eine IDE verwenden, können Sie das Programm direkt von dort starten. Auch dazu finden Sie im Anhang eine Anleitung. Auf der Kommandozeile ist das Programm unter dem Namen a.out gespeichert worden, und es kann gestartet werden:

> ./a.out
Geben Sie eine Zahl ein:

Ausführung

include

#include <iostream>

Die erste Zeile enthält einen #include-Befehl. Dieser Befehl liest die Datei iostream.h an dieser Stelle in den Quelltext ein. Er wird gebraucht, um Informationen über Programmbibliotheken einzubinden. In diesem Fall geht es um die Bibliothek für die Ein- und Ausgabe (iostream). Die grundlegende Funktionalität dafür müssen Sie nicht selbst schreiben, sondern sie wird mit dem Compiler in einer Standardbibliothek mitgeliefert. Sie können sie einfach nutzen. Wenn also eine Ein- oder Ausgabe im Programm verwendet werden soll, muss zu Anfang der Datei dieser Befehl stehen, der die Datei iostream einfügt. Die Datei iostream enthält die Informationen, die der Compiler braucht, um mit der Bibliothek arbeiten zu können. Welche Dateien per #include eingebunden werden müssen, finden Sie in der Dokumentation der verwendeten Funktionen beschrieben bzw. an den entsprechenden Stellen in diesem Buch.

using namespace std;

int main()
{

main(){ }

Einrückung

int Eingabe;
int Quadrat;

int

Typen

Typ	Daten
int	Ganze Zahlen
short	Ganze Zahlen (typischerweise --32.768 bis 32.767)
long	Ganze Zahlen (typischerweise --2.147.483.648 bis 2.147.483.647)
float	Fließkommazahlen (beispielsweise --2,5 oder 3,14159)
double	Fließkommazahlen höherer Genauigkeit
long double	Fließkommazahlen mit besonder großer Genauigkeit
char	Buchstaben oder ganze Zahlen von --128 bis 127

cout << "Geben Sie eine Zahl ein: ";

cout

cin >> Eingabe;

cin

Das Thema Ein- und Ausgabe wird noch einmal unter dem Aspekt der Anwendung. und dann noch einmal vertieft dargestellt.

Quadrat = Eingabe * Eingabe;

Berechnung

Neben dem Stern (*) als Multiplikationszeichen gibt es den Schrägstrich (/) als Divisionszeichen, das Pluszeichen (+) für die Addition und das Minuszeichen (-) für die Subtraktion. Die Tabelle zeigt eine Übersicht der grundlegenden Operatoren.

Operator	Bedeutung
+	Addition
-	Subtraktion
*	Multiplikation
/	Division
=	Zuweisung
<<	Umleitung (typischerweise nach cout)
>>	Umleitung (typischerweise von cin)

Abkürzungen

cout << "Die Quadratzahl lautet " << Quadrat << endl;

nochmal cout

Abfrage und Schleifen

Programme müssen nicht nur Zeile für Zeile ablaufen. Es ist möglich, Programmteile aufgrund des Zustands von Variablen zu übergehen oder zu wiederholen.

Abfrage und boolesche Ausdrücke

Mit Hilfe der Abfrage können Sie einen Anweisungsblock unter eine angegebene Bedingung stellen. Beispielsweise können Sie prüfen, ob die Zahl, durch die Sie gerade teilen wollen, vielleicht 0 ist.

[Sichern gegen eine Division durch null]
if (divisor==0)
{
    cout << "Division durch 0" << endl;
}
else
{
    quotient = dividend / divisor;
}

if else

Vergleiche

[Programmausschnitt]
if (Eingabe>=5 && Eingabe<=10)

Und-Verknüpfung

Der Gesamtausdruck einer Und-Verknüpfung wird wahr, wenn beide Teilausdrücke wahr sind.

Oder-Verknüpfung

Der Gesamtausdruck einer Oder-Verknüpfung wird wahr, wenn mindestens einer der Teilausdrücke wahr ist.

Negation

[Programmausschnitt]
if (!(Eingabe>=5 && Eingabe<=10))

Die Klammer hinter dem Ausrufezeichen bewirkt, dass der gesamte Ausdruck negiert wird und nicht nur der erste. Sie können also Klammern auch in logischen Ausdrücken verwenden, um Prioritäten zu setzen.

Näheres zu den Verknüpfungen von Bedingungen finden Sie an anderer Stelle. Zusammenfassend zeigt die Tabelle die logischen Operatoren.

Operator	Bedeutung
==	Gleichheit
!=	Ungleichheit
<	Kleiner
<=	Kleiner oder gleich
>	Größer
>=	Größer oder gleich
!	Negation eines booleschen Ausdrucks (NOT)
&&	Und-Verknüpfung (AND)
||	Oder-Verknüpfung (OR)

Die while-Schleife

In Schleifen kann eine Anweisung oder ein Block von Anweisungen so lange wiederholt werden, wie die Schleifenbedingung zutrifft.

[Zahleneingabe]
#include <iostream.h>

main()
{
    int InZahl = 0;
    while (InZahl<1 || InZahl>6)
    {
        cout << "Geben Sie eine Zahl von 1 bis 6 ein!";
        cin >> InZahl;
    }
}

Schleifenbedingung

Schleifenkörper

Initialisierung

Die while-Schleife wird an anderer Stelle noch einmal ausführlicher besprochen.

Die for-Schleife

Die Schleife for ist eine Sonderform der while-Schleife. Die Initialisierung, die Bedingung für das Verbleiben in der Schleife und die Anweisung zum Erreichen des nächsten Schritts befinden sich im Kopf der Schleife. Dadurch wird erreicht, dass man keinen der wichtigen Aspekte einer Schleife vergisst. Die for-Schleife ist etwas abstrakter als die while-Schleife, aber dafür etwas übersichtlicher, wenn man sich an sie gewöhnt hat. Die for-Schleife wird besonders dann verwendet, wenn Dinge abgezählt werden.

Das folgende Programm erstellt eine Liste der ersten zehn Quadratzahlen auf dem Bildschirm.

[Quadratzahlen]
#include <iostream.h>
main()
{
    int i;
    for (i=1; i<=10; i++)
    {
        cout << i << ": " << i*i << endl;
    }
}

Wenn Sie das Programm starten, erscheinen in der linken Spalte die Zahlen von 1 bis 10. Darauf folgt in jeder Zeile ein Doppelpunkt, ein Leerzeichen und dann die Quadratzahl.

Klammerinhalt

Nähere Informationen zur for-Schleife finden Sie an anderer Stelle.

Arrays

Ein Array ist ein Datenverbund mehrerer gleichartiger Variablen. Dabei stehen die Variablen in einer Reihe direkt nebeneinander. Das ganze Array hat einen Namen. Um ein einzelnes Element eines Arrays anzusprechen, wird die Positionsnummer verwendet.

Ein typisches Beispiel für ein Array sind die Lottozahlen. Es handelt sich um sechs völlig gleichwertige Zahlen, die nur zusammen interessant sind. Sie können in einer Array-Variablen namens lotto abgelegt werden. Diese Variable muss Platz für sechs ganze Zahlen haben. Um eine einzelne Zahl anzusprechen, wird der Variablenname lotto genannt und danach in eckigen Klammern die Position, an der die einzelne Zahl steht. Also beispielsweise lotto[3]. In allen Arrays steht das erste Element an der Stelle 0. Damit ist lotto[0] die erste Lottozahl und lotto[3] die vierte. Die Abbildung zeigt diesen Zusammenhang.

Im folgenden Listing wird eine Array-Variable für die Lottozahlen definiert und einzeln mit den Lottozahlen aus Abbildung \gpVerweis{arraylotto} gefüllt. Anschließend werden die Zahlen in einer for-Schleife ausgegeben.

[Lottozahlen]
#include <iostream.h>

main()
{
    int lotto[6];
    lotto[0] = 5;
    lotto[1] = 12;
    lotto[2] = 13;
    lotto[3] = 28;
    lotto[4] = 32;
    lotto[5] = 43;
    int i;
    for (i=0; i<6; i++)
    {
        cout << lotto[i] << "  ";
    }
    cout << endl;
}

Definition

Zeichenketten

Die Grafik in der folgenden Abbildung zeigt ein Array von char, in dessen ersten drei Elementen sich die Buchstaben 'K', 'a' und 'i' befinden. Im vierten Element mit dem Index 3 befindet sich eine Null. Der Zustand der restlichen zwei Elemente ist unbestimmt.

[Gefülltes char-Array]

Das nachfolgende Programm verdeutlicht, wie Sie Texte eingeben können. Dazu wird die Funktion cin.getline() verwendet. Anschließend wird der Name ausgegeben und in eine andere Variable kopiert. Zum Test wird die Kopie auch noch einmal auf dem Bildschirm angezeigt.

[Begrüßung (gruss.cpp)]
#include <iostream.h>

main()
{
    char Name[80];
    cout << "Wie heißen Sie?" << endl;
    cin.getline(Name, 80);
    cout << "Guten Tag, " << Name << "!" << endl;
    char Kopie[80];
    int i;
    for (i=0; Name[i] && i<79; i++)
    {
        Kopie[i] = Name[i];
    }
    Kopie[i] = 0;
    cout << "Das ist Ihre Kopie: " << Kopie << endl;
}

Zu Anfang wird wieder die Datei iostream.h eingebunden. Dann beginnt die Funktion main().

char Name[80];

Für den einzugebenden Namen wird eine Array-Variable namens Name angelegt, die bis zu 80 Zeichen aufnehmen kann. Da aber jede Zeichenkette ihre Abschluss-Null benötigt, stehen netto 79 Buchstaben zur Verfügung.

cout << "Wie heißen Sie?" << endl;
cin.getline(Name, 80);

Zeileneingabe

cout << "Guten Tag, " << Name << "!" << endl;

Nun wird die Begrüßung ausgegeben. Der eben eingegebene Name wird in diese Zeile eingefügt. Man sieht das daran, dass Name nicht in Anführungszeichen steht. Dann ist immer die Variable gemeint. Sie sehen hier, dass char-Arrays auch direkt ausgegeben werden können, ohne auf die Buchstaben einzeln zugreifen zu müssen.

char Kopie[80];
int i;

Hier werden zwei Variablen definiert. Die erste ist ein Array, das exakt so definiert wurde wie der Name. Als Zweites wird die Integer-Variable i definiert, die als Zähler und Index benutzt wird.

for (i=0; Name[i] && i<79; i++)

Hier beginnt die for-Schleife, die den Inhalt der Variablen Name in die Variable Kopie kopiert. Die Schleife setzt zunächst den Index i auf null.

Zwischen den Semikola steht die Bedingung, unter der in der Schleife verblieben wird. Die Bedingung sieht etwas originell aus. Betrachten wir zunächst den Teil links von der Und-Verknüpfung \&\&. Name[i] liefert nur das Zeichen, das an der aktuellen Stelle steht. Da jede Zeichenkette aber mit einer 0 endet und 0 in C++ als falsch interpretiert wird, endet die Schleife sofort, wenn im Original das Ende der Zeichenkette erkannt wird. Durch die Und-Verknüpfung reicht es aus, dass ein Teil falsch ist und die Gesamtbedingung für das Verbleiben in der Schleife nicht mehr erfüllt ist. Damit die Schleife weiterläuft, muss auch erfüllt sein, dass die Zeichenkette kleiner als 79 bleibt. Der Index auf das Array Kopie muss kleiner als 79 sein. Denn das Array ist so definiert worden, dass es maximal 80 Elemente fasst. Da das erste Element, wie in jedem Array, die Position 0 hat, darf das höchste Element nur an Position 79 stehen. Da es aber eine Zeichenkette ist, muss auch Platz für die Abschluss-Null sein. Also wird der Index bereits bei kleiner 79 abgefangen.

Im dritten Teil wird als Abschlussanweisung die Variable i erhöht. Damit wird garantiert, dass die Schleife eines Tages endet, sobald i 79 oder größer wird.

{
    Kopie[i] = Name[i];
}

Die geschweiften Klammern gehören zur for-Schleife und umschließen die Anweisungen, die in der Schleife ausgeführt werden. Das ist nur eine Zeile. Hier wird der i-te Buchstabe des Arrays Name in das entsprechende Element des Arrays Kopie} kopiert. Da die Schleife dafür sorgt, dass \gpfett{i von 0 bis zum letzten Buchstaben läuft, wird also der komplette Name übernommen.

Kopie[i] = 0;

Abschluss setzen

Zum Thema Zeichenketten finden Sie Informationen auf Seite~\gpSeitenverweis{cstring} und zur Klasse string ab Seite~\gpSeitenverweis{string}.

Funktionen

Mit einer Funktion können Sie mehrere Anweisungen so zusammenfassen, dass sie von beliebiger Stelle im Programm durch einen einzigen Befehl aufzurufen sind. Dadurch werden größere Programme übersichtlicher. Befindet sich in der Funktion eine Sequenz von Anweisungen, die öfter benötigt wird, wird das Programm darüber hinaus auch kürzer.

Programmaufteilung

Als Beispiel wird das Programm aus Listing \gpVerweis{prggruss} in drei Funktionen zerlegt. Die erste Funktion nimmt die Eingabe des Benutzers entgegen, die zweite kopiert den Namen, und die dritte gibt die Meldung aus.

[Begrüßung in Funktionen aufgeteilt (fgruss.cpp)]
#include <iostream.h>

char Name[80];
char Kopie[80];

void EingabeName()
{
    cout << "Wie heißen Sie?" << endl;
    cin.getline(Name, 80);
    cout << "Guten Tag, " << Name << "!" << endl;
}

void Kopiere()
{
    int i;
    for (i=0; Name[i] && i<79; i++)
    {
        Kopie[i] = Name[i];
    }
    Kopie[i] = 0;
}

void ZeigeKopie()
{
    cout << "Das ist Ihre Kopie: " << Kopie << endl;
}

main()
{
    EingabeName();
    Kopiere();
    ZeigeKopie();
}

Die Anweisungen haben sich nicht verändert. Lediglich die Anordnung ist neu. Der Inhalt der Funktion main() ist wesentlich übersichtlicher geworden. Es stehen nur noch die drei Funktionsaufrufe darin. Betrachten wir wieder die Anweisungen im Einzelnen:

char Name[80];
char Kopie[80];

Globale Arrays

void EingabeName()
{
    cout << "Wie heißen Sie?" << endl;
    cin.getline(Name, 80);
    cout << "Guten Tag, " << Name << "!" << endl;
}

Das ist die Funktion EingabeName(). Der Funktionsname folgt den gleichen Regeln wie der Name einer Variablen. Vor dem Funktionsnamen steht immer der Typ des Rückgabewerts. Da diese Funktion gar keinen Rückgabewert hat, ist dieser Typ void. Man könnte das englische Wort »void« mit »leer« oder »unbesetzt« übersetzen. Das Klammerpaar enthält die Parameter. Diese Funktion hat keine Parameter, also ist die Klammer leer. Sie könnten auch das Schlüsselwort void zwischen die Klammern schreiben. Das bewirkt das Gleiche. Es folgt die öffnende geschweifte Klammer. Alle Anweisungen, die nun bis zur passenden schließenden Klammer folgen, werden ausgeführt, wenn die Funktion EingabeName() aufgerufen wird. Die folgenden drei Zeilen kennen Sie schon aus Listing \gpVerweis{prggruss}. Die erste gibt auf dem Bildschirm eine Meldung an den Benuter, was er tun soll. Die zweite Zeile liest die Benutzereingabe in die Array-Variable Name, und die dritte verwendet die Variable Name für eine angepasste Rückmeldung an den Benutzer. Die folgende schließende geschweifte Klammer schließt die Funktion ab.

void Kopiere()
{
    int i;
    for (i=0; Name[i] && i<79; i++)
    {
        Kopie[i] = Name[i];
    }
    Kopie[i] = 0;
}

Die Funktion Kopiere() ist ebenfalls eine Funktion ohne Rückgabewert und Parameter. In dieser Funktion ist die Variable i definiert. Sie ist eine lokale Variable dieser Funktion. Außerhalb der Funktion ist sie nicht zu sehen. Würden in anderen Funktionen ebenfalls Variablen mit dem Namen i angelegt, würden sie sich nicht gegenseitig stören.

Die letzte Funktion bringt nicht viel Neues, darum wenden wir uns gleich der Funktion main() zu.

main()
{
    EingabeName();
    Kopiere();
    ZeigeKopie();
}

Der Aufruf der Funktionen kann beliebig oft an beliebigen Stellen des Programms erfolgen. Würde beispielsweise die Eingabe des Namens an anderer Stelle noch einmal erforderlich sein, bräuchte dort nur noch einmal die Anweisung EingabeName(); verwendet werden, und die entsprechenden Befehle würden ausgeführt. Ist es möglich, Funktionen zu bilden, die im Programm mehrfach anwendbar ist, ersparen Sie sich viel Tipparbeit. Hinzu kommt, dass Sie die Funktion beim zweiten Mal nicht noch einmal testen müssen, da sie ja bereits getestet ist.

Rückgabewert

Im Beispiel benötigten die Funktionen keinen Rückgabewert. In vielen Fällen soll aber die Funktion Informationen an den Aufrufer zurückliefern. Das kann eine Berechnung, aber auch eine Fehlermeldung sein.

[Parameterübergabe]
float zaehler, nenner;

float Teilen()
{
    return zaehler/nenner;
}

main()
{
    float quotient; 
    zaehler = 26;
    nenner = 4;
    quotient = Teilen();
}

Das Programm hat die Aufgabe, zwei Zahlen durch einander zu teilen. Dabei befinden sich der Zähler und der Nenner je in einer globalen Variablen. Die Division wird in der Funktion Teilen() durchgeführt, die das Ergebnis an den Aufrufer zurückgibt. (Natürlich ist das wesentlich umständlicher, als direkt an Ort und Stelle zu dividieren. Aber wenn Sie konsequent sind, dürften Sie auch kein C++-Programm schreiben, um zwei Zahlen zu dividieren. Da würden Sie einen Taschenrechner benutzen oder den Nachbarn fragen.)

float Teilen()

Der Rückgabewert der Funktion Teilen() ist vom Typ float. Dieser Rückgabetyp einer Funktion steht immer am Anfang einer Funktionsdefinition. Es folgt der Funktionsname und die bereits bekannten Klammern. Der Rückgabewert wird durch den Befehl return an den Aufrufer zurückgegeben.

return zaehler/nenner;

Der Befehl return beendet eine Funktion sofort. Besitzt sie einen Rückgabewert, muss hinter dem return stehen, was die Funktion an den Aufrufer als Ergebnis liefert. Im Beispiel ist der Rückgabewert die Division der Variablen zaehler und nenner.

main()

quotient = Teilen();

In dieser Zeile enthält die Variable quotient den Wert, den der Befehl return in der Funktion zurückgibt. Obwohl die Funktion keine Parameter entgegennimmt, sind die Klammern zur Kennzeichnung eines Aufrufs unbedingt erforderlich. Sollten Sie eine Funktion aufrufen wollen und ihren Rückgabewert nicht benötigen, brauchen Sie keine Zuweisung an eine Variable durchzuführen. Sie können die Funktion genau so aufrufen, als wäre sie vom Typ void. Im Fall der Funktion Teilen() sähe solch ein Aufruf so aus:

Teilen();

In diesem speziellen Beispiel wäre das zwar völlig unsinnig, weil die Funktion ja nichts mehr tut, als den Rückgabewert zu berechnen. Aber ein solcher Aufruf ist syntaktisch einwandfrei. In anderen Fällen, in denen der Rückgabewert für das Programm wirklich bedeutungslos ist, hat ein solches Vorgehen den Vorteil, dass nicht Variablen mit Werten belegt werden, die später nicht mehr gebraucht werden.

Parameter

Am letzten Beispiel war schon zu sehen, dass es hochgradig unelegant ist, die Werte, die in der Funktion Teilen() verwendet werden sollen, vor dem Aufruf in globalen Variablen abzulegen. Stattdessen wäre es besser, die Variablen direkt an die Funktion zu übergeben. Zu diesem Zweck gibt es Parameter. Über die Parameter werden Werte an die Funktion übermittelt.

[Parameterübergabe]
float Teilen(float zaehler, float nenner)
{
    return zaehler/nenner;
}

main()
{
    float quotient;
    myfloat=26;
    quotient = Teilen(myfloat, 4);
}

Die Variablen, mit denen eine Funktion arbeitet, sind nun in der Kopfzeile einer Funktionsdefinition zu sehen. Entsprechend werden die globalen Variablen nicht mehr gebraucht.

float Teilen(float zaehler, float nenner)

Die Parameterdeklarationen zwischen den Klammern sehen wie Variablendefinitionen aus, die durch Kommata getrennt werden. Tatsächlich haben die Parametervariablen auch das Verhalten lokaler Variablen. Die Werte, die beim Funktionsaufruf zwischen den Funktionsklammern stehen, werden in diese Variablen kopiert. Das Thema lokale Variablen wird an anderer Stelle ausführlicher behandelt.

quotient = Teilen(myfloat, 4);

Die Funktion Teilen() kann auf den Wert der Variablen myfloat über die lokale Variable zaehler zugreifen. Beim Aufruf der Funktion wird der Wert übergeben. Die Zahl 4, also der zweite Aufrufparameter wird beim Aufruf in die Variable nenner kopiert.

Adressenübergabe

Adressen und Zeiger

[Parameterübergabe]
void Kuerzen(int *zaehler, int *nenner)
{
    int teiler;
    teiler = ggt(*zaehler, *nenner);
    *zaehler = *zaehler/teiler;
    *nenner  = *nenner /teiler;
}

main()
{
    int z=14;
    int n=6;
    Kuerzen(&z, &n);
}

Die Funktion Kuerzen() nimmt Zähler und Nenner entgegen und kürzt die beiden Werte. Die Funktion verändert also die Variableninhalte von z und n, obwohl sie lokale Variablen der Funktion main() sind. Der Aufrufer übergibt dazu die Adressen der Variablen an die Funktion. In der Parameterdefinition sehen Sie, dass die Variablen zaehler und nenner als Zeiger auf eine Variable vom Typ int definiert sind. Sie nehmen also Adressen von Integer-Variablen auf und haben selbst keinen Wert außer der Adresse. Nach der Parameterübergabe enthält zaehler die Adresse der Variablen z. In der Funktion muss nun jedes Mal, wenn auf den Inhalt von z} zugegriffen werden soll, der Variablen \gpfett{zaehler ein Stern vorangestellt werden. Dadurch wird nicht auf die Adresse zugegriffen, sondern auf den Wert, auf den die Zeigervariable zeigt.

ggT

Sie finden im weiteren Text mehr Informationen zum Thema Zeigerparameter und zum Thema Zeigervariablen.

Arrays als Parameter

[Durchschnittsberechnung]
double avg(int Anzahl, double Wert[])
{
    int i;
    long double Summe=0;

    for (i=0; i<Anzahl; i++)
    {
        Summe += Wert[i];
    }
    return Summe/Anzahl;
}

Parameter

long double

Der Durchschnitt wird ermittelt, indem innerhalb der for-Schleife die Summe aller Array-Elemente berechnet wird und diese durch die Anzahl der Elemente geteilt wird.

Zum Thema Array-Parameter finden Sie weitere Informationen an anderer Stelle.

Klassen

Programmieren heißt, die Welt in Ausschnitten zu modellieren. Die meisten Objekte der Welt sind allerdings zu komplex, als dass sie allein mit einer Fließkommavariablen oder einem Array darstellbar sind. Eine Person hat aus Sicht eines Programms einen Namen, eine Adresse, einen Geburtstag und ein Einkommen. Ein Auto besteht aus Marke, Typ, Leistung und Wert. Für die Nachbildung solcher Objekte müssen verschiedene Typen zusammengestellt werden. Dazu verwendet man in C++ Klassen. Das folgende Beispiel zeigt eine Klasse für ein Auto.

[Die Klasse Auto]
class Auto
{
public:
    char Marke[20];
    char Typ[30];
    int kW;
    float Wert;
};

Mit dieser Definition wurde der Typ Auto angelegt. Es kann nun eine Variable vom Typ Auto angelegt werden. Man sagt auch, dass ein Objekt der Klasse Auto erzeugt wird. Man spricht bei einem Objekt auch von einer Instanz einer Klasse.

Objekt

\begin{gpBeispiel} Für eine wirtschaftliche Software soll die Ware erfasst werden. Ein Artikel besteht aus einer Bezeichnung, einem Strichcode und einem Preis.

[Ware]
const int MaxBez=40;
const int MaxCode=20;

class tWare
{
public:
    char Bezeichnung[MaxBez];
    char Strichcode[MaxCode];
    float Preis;
};

main()
{
    tWare Schokoriegel;
    Schokoriegel.Preis = 0.70;
}

Wir betrachten wieder die Zeilen einzeln:

const int MaxBez=40;
const int MaxCode=20;

const

class tWare
{
public:

Klassenname

    char Bezeichnung[MaxBez];
    char Strichcode[MaxCode];
    float Preis;
};

Elemente

tWare Schokoriegel;
Schokoriegel.Preis = 0.70;

Klassendefinition

Objektorientierung

Im Falle der Klasse tWare soll eine Preisänderung möglich sein. Allerdings ist es bei einer solch wichtigen Entscheidung wie der Preisgestaltung erforderlich, dass protokolliert wird, wenn der Preis geändert wird. Aus diesem Grund erhält die Klasse tWare eine Funktion namens NeuPreis(). Diese Funktion soll den Preis ändern und die Protokollierung veranlassen.

Um sicherzustellen, dass jede Preisänderung so behandelt wird, muss erzwungen werden, dass nur über die Funktion NeuPreis() auf das Datenelement Preis zugegriffen werden kann. Dazu wird es vor der Außenwelt versteckt, indem es als privat definiert wird. Danach wird ein direkter Zugriff auf den Preis, wie er in Listing \gpVerweis{prgwareclass} erfolgte, vom Compiler verhindert. Das Datenelement Preis kann dann nur noch von Elementfunktionen der Klasse (in diesem Fall durch NeuPreis()) verändert werden.

[Preisänderung]
class tWare
{
public:
    char Bezeichnung[MaxBez];
    char Strichcode[MaxCode];
    void NeuPreis(float neuerPreis);
private:
    float Preis;
};

void tWare::NeuPreis(float neuerPreis)
{
    Protokolliere(Preis, neuerPreis);
    Preis = neuerPreis;
}

main()
{
    tWare Schokoriegel;
    Schokoriegel.NeuPreis(0.70);
}

Betrachten wir die Änderungen, die sich im Listing ergeben.

    void NeuPreis(float neuerPreis);
private:
    float Preis;

Klassendefinition

void tWare::NeuPreis(float neuerPreis)

Hier wird die Elementfunktion NeuPreis() der Klasse tWare definiert, also ausprogrammiert. Um sie von normalen Funktionen zu unterscheiden, die nicht zur Klasse gehören, wird dem Funktionsnamen der Klassenname mit zwei Doppelpunkten vorangestellt.

{
    Protokolliere(Preis, neuerPreis);
    Preis = neuerPreis;
}

Es folgt der Funktionsrumpf mit den geschweiften Klammern. Zunächst wird eine Funktion Protokolliere() aufgerufen, deren Inhalt uns nicht bekannt ist und uns auch nicht weiter interessieren soll. Gehen Sie einfach davon aus, dass sie von einem Kollegen geschrieben werden soll. Innerhalb einer Elementfunktion kann direkt auf die Datenelemente der Klasse zugegriffen werden. Machen Sie sich klar, dass die Funktion als Bestandteil eines Objekts aufgerufen wird. Greift die Funktion auf die Variable Preis zu, dann ist das der Preis des Objekts, über das die Funktion aufgerufen wurde.

tWare Schokoriegel;
Schokoriegel.NeuPreis(0.70);

Der Aufruf der Funktion NeuPreis() erfolgt wie der Zugriff auf Datenelemente der Klasse, indem zunächst das Objekt genannt wird, auf das die Funktion angewendet wird, dann ein Punkt und schließlich der Funktionsaufruf.

Konstruktor

Klassen ermöglichen es, Elementfunktionen zu definieren, die automatisch aufgerufen werden, wenn ein Objekt der Klasse erzeugt wird. Damit kann der Programmierer dafür garantieren, dass das Objekt immer korrekt initialisiert ist. Konstruktoren tragen den Namen der Klasse und haben keinen Rückgabewert, auch nicht void.

Konstruktor

[Konstruktor]
class tWare
{
public:
    tWare(); // Konstruktordeklaration
    char Bezeichnung[MaxBez];
    char Strichcode[MaxCode];
    void NeuPreis(float neuerPreis);
    float Bestand;
private:
    float Preis;
};

tWare::tWare()
{
    Bezeichnung[0] = 0;
    Strichcode[0]  = 0;
    Preis = 0.0;
    Bestand = 0.0;
}

void tWare::NeuPreis(float neuerPreis)
{
    Protokolliere(Preis, neuerPreis);
    Preis = neuerPreis;
}

main()
{
    tWare Schokoriegel;
    Schokoriegel.NeuPreis(0.70);
}

Die Deklaration des Konstruktors erfolgt in der Klasse als öffentliche Elementfunktion. Einige Teile des Listings sollen detailliert betrachtet werden:

class tWare
{
public:
    tWare(); // Konstruktordeklaration

Vor dem Namen des Konstruktors tWare darf kein Datentyp stehen, auch nicht void. Da der Konstruktor keinen Parameter hat, nennt man ihn Standardkonstruktor.

tWare::tWare()
{

Die Definition des Konstruktors erfolgt analog zu jeder Elementfunktion. Der Klassenname steht, abgetrennt durch zwei Doppelpunkte, vor dem Funktionsnamen, der in diesem Fall der Klassenname ist.

    Bezeichnung[0] = 0;
    Strichcode[0]  = 0;
    Preis = 0.0;
    Bestand = 0.0;
}

Die Anweisungen des Konstruktors sind ganz typisch. Es werden alle Datenelemente der Klasse auf einen Anfangswert gesetzt. Die Zeichenketten werden geleert, indem bereits ihr erstes Element mit der Abschluss-Null besetzt wird.

tWare Schokoriegel;

Sobald die Variable Schokoriegel angelegt wird, wird für dieses Objekt die Funktion tWare::tWare() aufgerufen. Damit sorgt der Konstruktor vor dem allerersten Zugriff dafür, dass alle Datenelemente in einem definierten Zustand sind.

Konstruktoren mit Parametern

Konstruktoren können mit Parametern versehen werden. Dadurch kann erreicht werden, dass das Objekt bereits beim Anlegen mit bestimmten Eigenschaften initialisiert wird. Diese Parameter werden dann beim Anlegen der Variablen in einer angehängten Klammer bedient.

Im folgenden Listing wird ein Konstruktor hinzugefügt, der als Parameter die Bezeichnung und den Strichcode hat. Dadurch können Objekte bereits beim Anlegen mit beiden Informationen belegt werden.

[Preisänderung]
class tWare
{
public:
    tWare();
    tWare(char *Bez, char *Code);
    char Bezeichnung[MaxBez];
    char Strichcode[MaxCode];
    float Bestand;
    void NeuPreis(float neuerPreis);
private:
    float Preis;
};

tWare::tWare()
{
    Bezeichnung[0] = 0;
    Strichcode[0]  = 0;
    Preis = 0.0;
    Bestand = 0.0;
}

tWare::tWare(char *Bez, char *Code)
{
    strcpy(Bezeichnung, Bez);
    strcpy(Strichcode, Code);
    Preis = 0.0;
    Bestand = 0.0;
}

void tWare::NeuPreis(float neuerPreis)
{
    Protokolliere(Preis, neuerPreis);
    Preis = neuerPreis;
}

main()
{
    tWare Schokoriegel("LeckerSchlecker", "4008400404127");
    Schokoriegel.NeuPreis(0.70);
}

Der neue Konstruktor unterscheidet sich nur im Parameter von dem Standardkonstruktor.

public:
    tWare();
    tWare(char *Bez, char *Code);
...
tWare::tWare()
...
tWare::tWare(char *Bez, char *Code)

Der Konstruktor mit Parametern muss auch die Elemente Preis und Bestand initialisieren. Der Standardkonstruktor wird weder vorher noch nachher automatisch aufgerufen. Ein Konstruktor mit Parametern ist also ein eigenständiger Konstruktor, der alternativ zum Standardkonstruktor aufgerufen wird.

tWare Schokoriegel("LeckerSchlecker", "4008400404127");

Die Klasse tWare hat nun also zwei Konstruktoren. Der eine initialisiert die Warenbezeichnung und den Strichcode beim Anlegen. Der andere benötigt keine Parameter und wird deswegen auch Standardkonstruktor genannt. Er wird aufgerufen, wenn bei einer Variablendefinition kein Parameter angegeben wird. Wenn Sie den Standardkonstruktor aus der Klasse tWare entfernen, ist es nicht mehr möglich, ein Objekt von tWare anzulegen, ohne ihm eine Bezeichnung und einen Strichcode mitzugeben. Sie können so erzwingen, dass alle Waren zu Anfang eine Bezeichnung und einen Strichcode besitzen. Weitere Informationen zum Thema Konstruktoren finden Sie ab Seite~\gpSeitenverweis{konstruktor}.

Überladen

Vererbung

Nicht alle Waren sind gleich. So wird auf Getränke in Flaschen beispielsweise Pfand erhoben. Soll das Pfand ebenfalls in der Ware gespeichert werden, dann könnten Sie die Klasse tWare um ein Datenelement namens Pfand ergänzen. Allerdings wird nicht auf alle Waren Pfand erhoben. Sie könnten nun die Klasse tWare kopieren, das Pfand einfügen und umbenennen. Dann gäbe es zwei unabhängige Klassen. In C++ gibt es aber eine elegantere Lösung. C++ bietet Ihnen auch an, eine neue Klasse tPfandware anzulegen und zu erklären, dass sie alle Eigenschaften von tWare übernehmen soll. Man spricht davon, dass die Klasse tWare ihre Eigenschaften an die Klasse tPfandware vererbt. Man sagt auch, dass sich die Klasse tPfandware von der Klasse tWare ableitet. tWare} ist damit die Basisklasse von \gpfett{tPfandware.

Um das im Programm auszudrücken, werden bei der Definition der abgeleiteten Klasse nur ein Doppelpunkt, das Schlüsselwort public und der Name der Basisklasse an den Klassenkopf gehängt.

[Abgeleitete Klasse]
class tPfandware : public tWare
{
public:
    tPfandware(char *Bez, char *Code) : tWare(Bez, Code)
    {
        Pfand = 0.0;
    }
    void NeuPfand(float neuesPfand)
    {
        Pfand = neuesPfand;
    }
private:
    float Pfand;
};

Betrachten wir wieder die Zeilen im Einzelnen:

class tPfandware : public tWare

Die Klasse tPfandware erbt alle Elemente, die die Klasse tWare hat. Jedes Objekt der Klasse tPfandware hat also eine Bezeichnung, einen Strichcode, einen Preis und einen Bestand. Darüber hinaus erbt sie auch die Funktion NeuPreis().

Konstruktor

tPfandware(char *Bez, char *Code) : tWare(Bez, Code)
{
    Pfand = 0.0;
}

Hier wird ein so genannter Initialisierer an den Kopf des Konstruktors gehängt. Hinter dem Doppelpunkt wird der Konstruktor der Basisklasse aufgerufen. Die vom Initialisierer verwendeten Parameter sind die, die der Konstruktor tPfandware selbst übergeben bekommt. Der Konstruktor tPfandware braucht sich also nur um die zusätzlichen Elemente zu kümmern. In diesem Fall wurde die Definition des Konstruktors nicht außerhalb der Klassendefinition durchgeführt, sondern gleich in die Klasse integriert. Das ist bei so kleinen Funktionen durchaus sinnvoll. In dem Fall wird das Semikolon der Deklaration durch einen Funktionsrumpf ersetzt, dem dann kein Semikolon folgen darf.

Kompatibilität zur Basisklasse

Zuweisungen

main()
{
    tPfandware Blubberlutsch;
    tWare ZielWare;
    tWare *ZeigerWare;

    ZielWare = Blubberlutsch;   // das Pfand ist weg.
    ZeigerWare = &Blubberlutsch; // das Pfand bleibt.
}

Die Variable ZielWare enthält alle Informationen der Variablen Blubberlutsch}, die die Klasse \gpfett{tPfandware von der Klasse tWare geerbt hat. Alle Erweiterungen, hier also das Pfand, gehen verloren. Die Variable ZielWare hat ja auch keine Möglichkeiten, das Pfand zu speichern. Die Möglichkeit der Zuweisung macht intuitiv deutlich, dass eine Pfandware eben eine Ware ist. Eine Ware ist aber eben nicht immer eine Pfandware. Darum darf die Reihenfolge nicht umgedreht werden. Die Variable ZeigerWare} ist ein Zeiger auf den Typ \gpfett{tWare. Er kann auch auf ein Objekt einer abgeleiteten Klasse zeigen. Die Tatsache, dass dieser Zeiger auf Blubberlutsch zeigt, wird das Objekt nicht verändern. Es behält sein Pfand. Ihr Compiler würde aber den Versuch, über ZeigerWare auf das Pfand zuzugreifen, entrüstet abweisen, denn ein Zeiger auf tWare kennt kein Pfand.

Polymorphie

Bei einer Inventur werden alle Waren bewertet, natürlich auch die mit Pfand. Hier macht es sich bezahlt, dass wir nicht eine unabhängige zweite Klasse gebildet haben, sondern die Klasse tPfandware von der Klasse tWare abgeleitet haben. Denn Sie können eine abgeleitete Klasse in bestimmter Hinsicht wie die Basisklasse behandeln. Haben Sie eine Funktion zur Bestimmung des Inventurwertes für tWare geschrieben, können Sie diese natürlich auch für tPfandware aufrufen.

Inventurwert

Artikel-Array

[virtual InventurWert()]
class tWare
{
public:
    ...
    virtual float InventurWert();
    ...
};

Mit dem Schlüsselwort virtual wird dem Compiler signalisiert, dass bei einem Zugriff auf diese Variable nicht vorschnell auf die Klasse tWare zugegriffen werden soll, sondern dass das Objekt selbst bestimmen soll, welche Funktion InventurWert() zu ihr gehört. Wenn das einzelne Objekt festlegt, welche Funktion gestartet wird, nennt man dies Polymorphie. Im folgenden Listing sehen Sie die Schleife über das Array der Warenzeiger.

[Inventur]
tWare *Artikel[MaxArtikel];
int AnzahlArtikel;

for (int i=0; iBestand * Artikel[i]->InventurWert();
}

Pfeil

Bedingungen für Polymorphie

1. Das Objekt bleibt als solches erhalten und es wird darauf nur über einen Zeiger des Basisklassentyps zugegriffen.
2. Die aufgerufene Funktion wird in der Basisklasse mit dem Schlüsselwort virtual gekennzeichnet.

Die folgende Anweisung würde die Adresse eines Objekts der Klasse tPfandware in das Artikel-Array bringen, das oben für die Ermittlung der Inventur verwendet wird.

tPfandware Pulle("Malzbier", "")
Artikel[i] = &Pulle;

Durch die Polymorphie wird die Verantwortung für die Auswahl der Elementfunktionen dem Objekt übergeben. Nähere Informationen zum Thema Polymorphie finden Sie an anderer Stelle.

Templates

Mit den Templates verlassen wir den Bereich der objektorientierten Programmierung und wenden uns der so genannten generischen Programmierung zu. Man könnte die generische Programmierung fast als gegenläufigen Ansatz bezeichnen. Denn hier werden typunabhängige Algorithmen geschrieben.

Ein Template ist ein Muster, das typfrei vorgibt, wie ein Verfahren abzulaufen hat. Der Compiler stellt beim Aufruf fest, für welchen Typ eine Implementation des Template gebraucht wird, und erzeugt aus Template und Typ die benötigte Funktion oder Klasse.

Es wurde bereits zuvor eine Funktion vorgestellt, die den Durchschnitt aller Werte eines Arrays ermittelt. Die Funktion arbeitet mit Variablen vom Typ float. Das Verfahren, das in dieser Funktion angewandt wird, gilt aber nicht nur für Fließkommazahlen. Auf die gleiche Art und Weise würde auch der Durchschnitt von ganzzahligen Werten ermittelt. Zur Verdeutlichung des Unterschieds ist hier zunächst noch einmal diese Funktion zu sehen.

[Durchschnittsberechnung]
double avg(int Anzahl, double Wert[])
{
    int i;
    long double Summe=0;

    for (i=0; i<Anzahl; i++)
    {
        Summe += Wert[i];
    }
    return Summe/Anzahl;
}

Mit Hilfe einer Template-Funktion können Sie den Algorithmus einmal für alle Typen formulieren. Wenn Sie beide Funktionen miteinander vergleichen, können Sie leicht erkennen, nach welchem Strickmuster die Funktion quasi typ-anonymisiert wird.

[Durchschnittsberechnung per Template]
template  T avg(int Anzahl, T Wert[])
{
    int i;
    T Summe=0;

    for (i=0; i<Anzahl; i++)
    {
        Summe = Summe + Wert[i];
    }
    return Summe/Anzahl;
}

Am deutlichsten wird der Unterschied im Funktionskopf. Hier wird der Typ float durch den Ersatztyp T ersetzt.

template  T avg(int Anzahl, T Wert[])

Bevor aber T verwendet werden kann, wird es zunächst als Template-Typ eingeführt. Vor einer Template-Funktion erscheint als Erstes immer das Schlüsselwort template. Danach wird in spitzen Klammern beschrieben, welche Typen anonymisiert werden. Dazu wird der bekannte Begriff class verwendet. Dabei hat er hier wenig mit einer Klasse zu tun, sondern soll im Sinne von >>Typ« gemeint sein. Neuere Compiler akzeptieren auch alternativ das Schlüsselwort typename, das die Situation besser beschreibt. Der Name T steht also für den Typ, mit dem die Funktion später aufgerufen wird.

Nun erst beginnt der eigentliche Funktionskopf. Der Typ des Rückgabewertes ist T, also der gleiche wie für den zweiten Parameter. Dann kommt wie gehabt der Funktionsname und in Klammern die Parameter. Die Anzahl ist bei einer Durchschnittsberechnung natürlich immer ein int. Nur das übergebene Array soll im Typ veränderlich sein. Welcher Typ das T später ersetzt, ergibt sich durch die Parameter beim Aufruf der Funktion.

int i;
T Summe=0;

Innerhalb der Funktion wird der Typplatzhalter T nur noch einmal gebraucht, um die Variable zu definieren, die die Zwischensumme aufnimmt.

Aufruf

Gefragte Fähigkeiten

Analog zu Template-Funktionen können auch Template-Klassen gebildet werden. An dieser Stelle möchte ich den Schnelleinstieg beenden. Die Template-Klassen eignen sich nicht sehr gut, um sie in kurzen Sätzen zu erläutern. Sie finden nähere Informationen dazu hier.