Kapitel 3
Programmieren mit C++

Wenn Sie das Buch bis hierhin von Anfang an durchgearbeitet haben, ist Ihnen sicher eines aufgefallen: Sie wissen zwar nun einiges über Objektorientierung, aber nicht, wie man ganz elementare Abläufe in C++ programmiert. Vielleicht haben Sie auch einen Teil überblättert, um hierher zu gelangen, gerade weil Sie dieses Wissen vermisst haben (und nicht auf vorhandene C-Kenntnisse zurückgreifen konnten). Der Ansatz hier unterscheidet sich auch darin etwas von anderen Büchern. Kommen nämlich Beispiele für Kontrollstrukturen, Bedingungen etc. zu früh, besteht die Gefahr, dass Sie sich zu sehr an die dabei notgedrungen verwendete Programmierung im C-Stil gewöhnen und das objektorientierte Denken unterentwickelt bleibt.

In diesem Kapitel geht es nun um das eigentliche Programmieren mit der Sprache C++, insbesondere um folgende Aspekte:

• Wir beginnen mit Basiselementen wie Bedingungen und Kontrollstrukturen (ab Seite 288).
• Dann sehen wir uns an, wie man eine einfache Ein- und Ausgabe mittels Streams realisieren kann (ab Seite 316).
• Anschließend lernen Sie den Umgang mit Feldern, Zeigern und den Einsatz dynamischer Speicherverwaltung kennen (ab Seite 352).
• Der nächste Punkt ist die C++-Standardbibliothek, genauer gesagt die darin enthaltene C-Bibliothek mit ebenso praktischen wie unverzichtbaren Funktionen zu Numerik, Systemaufrufen und so weiter (ab Seite 400).
• Außerdem erfahren Sie, wie Sie selbst statische und dynamische Bibliotheken erstellen und in Ihren Entwicklungsprojekten einsetzen können (ab Seite 443).
• Schließlich will ich Ihnen noch ein paar allgemeine Konventionen und Ratschläge vorstellen, wie Sie Ihre C++-Programme lesbarer und fehlertoleranter gestalten können (ab Seite 468).

Da Sie nun schon das Wichtigste über objektorientierte Programmierung mit C++ wissen, sind die Beispiele in diesem Kapitel zum Teil etwas weniger trivial (und damit etwas ausführlicher) als bisher, denn sie sollen Ihnen zeigen, wie Sie die vorgestellten theoretischen Konzepte praktisch nutzen können. Folgende Beispiele machen Sie daher etwas näher mit der objektorientierten Programmierung unter Linux vertraut:

• Bei den Bedingungen lernen Sie, wie Sie unter Linux Datum und Uhrzeit bestimmen können (ab Seite 292).
• Bei der Mehrfachauswahl geht es um die Auswertung von Kommandozeilenparametern mit der getopt()-Funktion (ab Seite 298).
• Bei der Ein- und Ausgabe gehen wir der Frage nach, was ein Prozess ist, wie man seine Identifikationsnummer bestimmt und wie man aus einem Programm heraus andere Prozesse startet (ab Seite 346).

3.1 Basiselemente

Zu den grundlegenden Sprachelementen, auf die ich bislang nicht eingegangen bin, gehören die Bedingungen und die Konstrollstrukturen. Ohne sie kommt eigentlich kein Programm aus, das eine vernünftige Aufgabe erfüllen soll. Dieses Versäumnis wollen wir sofort nachholen.

3.1.1 Bedingungen

Eine der wichtigsten Kontrollelemente sind Verzweigungen aufgrund von Bedingungen. Kaum ein Programm läuft ganz geradlinig durch; fast immer muss überprüft werden, ob die eine oder andere Bedingung erfüllt ist, so dass in Abhängigkeit davon auf die eine oder andere Weise fortgefahren werden kann. Die Vorgehensweise ist dabei immer gleich: Wenn die Voraussetzung erfüllt ist, wird etwas ausgeführt, sonst etwas anderes. Die Wörtchen "wenn" und "sonst" heißen auf Englisch "if" und "else" und genauso heißen auch die Befehle in C++:

Wenn Sie auch etwas tun möchten, wenn die Bedingung nicht erfüllt ist, sieht das Ganze so aus:

Natürlich können Sie auch mehrere Anweisungen in jedem Teil ausführen; Sie müssen diese dazu nur in einen Block einschließen:

Das geht wieder mit und ohne else-Teil, in dem natürlich auch ein Block stehen darf.

Hinter der Bedingung darf kein Semikolon stehen, sonst wäre das nämlich eine leere Anweisung. Auch bezieht sich die bedingte Ausführung nur auf den einen Befehl hinter if oder auf den Block. Kompliziert? Ich werde Ihnen gleich anhand einiger typischer Fehler noch ein paar Tipps geben.

Doch zunächst zur Frage: Was ist eigentlich eine Bedingung? Es muss sich dabei um einen Ausdruck handeln, der einen Ganzzahltyp oder bool ergibt. Dabei können Sie alle Vergleichsoperatoren verwenden, also ¡, ¿, == und so weiter. Die Bedingung gilt als erfüllt, wenn sie true oder verschieden von 0 ist.

Die Ausdrücke dürfen auch logisch miteinander verknüpft werden, etwa durch die Operatoren && für die UND-Verknüpfung, -- -- für die ODER-Verknüpfung und ! für die Negation.

Beispiele sind:

Natürlich können Sie auch if-Ausdrücke beliebig tief verschachteln. Oft leidet aber die Übersichtlichkeit erheblich darunter. Zumindest sollten Sie jede Anweisung unterhalb der Bedingung einrücken, damit man sofort die Zusammengehörigkeit erkennt.

Typische Fehler bei if-Anweisungen

Überlegen Sie bitte bei jedem der folgenden Beispiele erst, wo der Fehler stecken könnte, bevor Sie die Erklärung lesen:

1. if (x==10);

     tuwas(x);

   Hier ist es das Semikolon hinter der Bedingung. Das hat zur Folge, dass die Funktion tuwas() immer ausgeführt wird, das heißt unabhängig vom Wert von x - und das war ja nicht beabsichtigt.

2. if (x=10)

     tuwas(x);

   Ein geradezu klassischer Fehler, den wohl jeder C++-Programmierer schon einmal gemacht hat. Zur Klarstellung: In C++ bedeutet ein Gleichheitszeichen = eine Zuweisung, erst zwei Gleichheitszeichen == stehen für einen Vergleich. Das Tückische ist, dass Zuweisungen immer auch so etwas wie einen Rückgabewert haben, nämlich den zugewiesenen Wert. Diesen akzeptiert dann der Compiler als Wert des Ausdrucks; in unserem Fall ist die Bedingung also immer erfüllt.

   Wenn Sie beim GCC die Option -Wall verwenden, weist Sie der Compiler auf dieses Problem mit der Meldung hin: "suggest parentheses around assignment used as truth value".

3. if (i==10)

     if (k==i)

       cout << ``i und k: 10!'' << endl;

   else

     cout << ``i ist nicht 10!'' << endl;

   Hier dürfen Sie sich nicht von der Einrückung der Zeilen täuschen lassen. Das else bezieht sich auf die letzte if-Anweisung, nämlich if(k==i), denn dort steht noch kein else-Teil. Wenn Sie möchten, dass sich die letzte Anweisung auf das erste if bezieht, müssen Sie die zweite und dritte Zeile zu einem Block klammern.

4. int c = -1;

   unsigned int k = 0;

   if (k<c)

     cout << ``k ist kleiner'' << endl;

   Erwarten Sie eine Ausgabe von diesem Codeteil? Eigentlich ist doch 0 größer als -1. Und doch wird diese Bedingung als erfüllt angesehen. Denn da die Typen der beiden Vergleichsgrößen verschieden sind, wandelt der Compiler den Typ der zweiten Vergleichsgröße in den Typ der ersten um, macht also aus -1 die Zahl 4294967295. Auch vor diesem Fehler warnt Sie der GCC, wenn Sie mit -Wall übersetzen.

Abkürzende Schreibweisen

Wir halten also fest: Eine Bedingung ist erfüllt, wenn das Ergebnis des Ausdrucks ungleich 0 ist. Wenn der Ausdruck aber nur aus einer Variablen oder Konstanten besteht, kann man eigentlich auch gleich deren Wert heranziehen und auf einen Vergleich verzichten. So lässt sich folgende, häufig anzutreffende Kurzschreibweise erklären.

Wenn Sie also eine Abfrage programmieren wollen, ob ein bestimmter Ausdruck ungleich 0 ist, genügt es, nur den Ausdruck als Bedingung anzugeben. Auf Beispiele werden wir noch treffen.

Beispiel: Telefontarife und Uhrzeitbestimmung

Seit der Liberalisierung des Telefonmarktes ist jeder nur noch damit beschäftigt, für das nächste Gespräch den günstigsten Anbieter zu finden. Das folgende Programm, das die Arbeit mit Bedingungen illustriert, besteht aus einer abstrakten Basisklasse Telefongesellschaft, die die Schnittstelle zur Preisberechnung allgemein vorgibt, und einer Unterklasse SiriusCom, die einen konkreten Anbieter darstellt. Dieser verlangt wochentags, also von Montag bis Freitag, von 7 bis 19 Uhr fünf Cent und sonst drei Cent pro Minute. Am Wochenende kostet die Minute Ferngespräch einheitlich zwei Cent.

Eine davon ist SiriusCom. Sie implementiert nur einen Konstruktor, in dem sie den Basisklassenkonstruktor aufruft (Zeile 37), um ihren Namen zu speichern, und die Berechnungsmethode berechneGebuehr().

Frage: Warum ist SiriusCom eigentlich eine Ableitung von Telefongesellschaft und nicht ein Objekt davon? Die Klasse Telefongesellschaft stellt doch eine Schablone dar, für die SiriusCom eine konkrete Ausprägung ist. Das ist in diesem Fall aber nur die halbe Wahrheit. SiriusCom kann kein Objekt sein, weil es nicht vollständig auf Methoden von Telefongesellschaft zurückgreifen kann, sondern auch eigene implementieren muss, in diesem Fall für die Tarifberechnung. Die abstrakte Klasse ist hier dazu da, die Schnittstelle festzulegen, aber nicht die Implementierung vorzugeben. Die Ableitung ist dabei die Spezialisierung, welche die Vorgaben aufnimmt und ihren eigenen Algorithmus hinzufügt. Mit einem Objekt wäre das nicht möglich (jedenfalls nicht, wenn man streng objektorientiert vorgeht und keine Tricks aus C versucht).

In der Methode SiriusCom::berechneGebuehr() sehen Sie in den Zeilen 48/49 zunächst, wie Sie in Ihren C++-Programmen die aktuelle Uhrzeit und das Datum vom Linux-System erfragen können. Vielleicht durchschauen Sie die Details der verwendeten Syntax momentan noch nicht; man muss dabei nämlich etwas mit Zeigern hantieren, die ich erst in einem der nächsten Abschnitte besprechen werde (Seite 352). Zumindest können Sie sich aber merken, dass sich bei der Abfrage am Ende eine so genannte Struktur ergibt. Unter einer Struktur versteht man eine Klasse, bei der alle Elemente, für die keine Zugriffsbeschränkung ausdrücklich angegeben ist, public sind. Man kennzeichnet sie mit dem Schlüsselwort struct. In diesem Fall hat die Struktur tm, die in der Header-Datei ctime definiert ist (Zeile 3!), sogar ausschließlich Attribute und keine Methoden.

Vielleicht fragen Sie sich noch, weshalb man eigentlich zwei Funktionen braucht, um auf so etwas Alltägliches wie Datum und Uhrzeit zu kommen. Das liegt an der Form, wie Linux die Zeit intern speichert. Unter Unix wird die Zeit stets in Sekunden nach dem 01.01.1970, 0:00:00 Uhr GMT, gemessen. Das Ergebnis von time() ist nichts anderes als die Zahl der Sekunden, die seitdem vergangen sind. Mit diesem Wert kann ein Benutzer aber nichts anfangen. Daher gibt es noch ein paar zusätzliche Funktionen, um die Umrechnung in gebräuchliche Einheiten vorzunehmen.

Doch zurück zu unserem Programm: Zwei der Attribute der Struktur tm sind tm_hour für die aktuelle Stunde und tm_wday, das den Wochentag angibt, wobei die Zählung mit 0 am Sonntag beginnt. Diese Attribute kopieren wir in den Zeilen 51/52 in lokale Variablen. Von Zeile 55 bis 73 geht es dann ganz um die Tarifbedingungen. Die äußere Bedingung (Zeile 55) ist erfüllt, wenn wochentag zwischen 1 und 5, also zwischen Montag und Freitag, liegt. In diesem Fall wird der Block von Zeile 56 bis 68 abgearbeitet. Die Anweisungen fürs Wochenende finden sich im else-Teil ab Zeile 70. Gemäß dem Tarif müssen wir an Werktagen noch die Uhrzeit überprüfen, was in Zeile 58 geschieht.

Der Rest des Programms besteht aus einer Ausgabe des Ergebnisses und natürlich der main()-Funktion. Damit sollten Sie keine Schwierigkeiten haben.

Das Beispiel zeigt Ihnen nicht nur die Verwendung der if-Anweisung, sondern auch, wie über Vererbung Zusammenhänge in einer Software repräsentiert werden können. Versuchen Sie am besten, das Programm um andere Anbieter zu erweitern und zusätzliche Funktionen oder Kriterien hinzuzufügen. Machen Sie sich auch die Beziehungen zwischen den von Ihnen verwendeten Klassen klar.

3.1.2 Mehrfache Auswahl

Es gibt immer wieder Fälle, in denen es mehr als nur zwei Möglichkeiten gibt. Diese können mit if-Abfragen nur sehr unzureichend behandelt werden, da sie zu sehr undurchsichtigem Code führen können. Besser ist es, einen Befehl zu verwenden, der mehrere Möglichkeiten zulässt. Dieser heißt in C++ switch und hat folgende Syntax:

Dabei müssen Sie Folgendes beachten:

• Der Ausdruck muss von einem ganzzahligen Typ sein, also beispielsweise char, int oder long. Es geht mit switch also nicht, dass Sie Verzweigungen in Abhängigkeit von Gleitkommazahlen, ganzen Textpassagen oder Objekten erstellen.
• Die Konstanten müssen ebenso einen ganzzahligen Typ haben und eindeutig sein. Stimmt der Wert des Ausdrucks mit einer Konstante überein, werden die zugehörigen Anweisungen ausgeführt. Während aber hinter if nur eine Anweisung stehen darf (mehrere Anweisungen hinter if erfordern die Zusammenfassung zu einem Block), sind bei case beliebig viele erlaubt. Eine Klammerung ist nicht zwingend erforderlich, in einigen Fällen indes sinnvoll.
• Die Abarbeitung der Anweisungen endet nicht automatisch beim folgenden case-Befehl. Sie wird so lange fortgesetzt, bis der switch-Block zu Ende ist oder eine break-Anweisung auftritt. Sie können break auch bei anderen Abläufen mit Blöcken finden. Diese Anweisung bedeutet stets: Beende die laufende Abarbeitung und verlasse den aktuellen Block, in unserem Fall den switch-Block (siehe auch Seite 310). Sie sollten alle case-Anweisungsfolgen mit break abschließen - sonst laufen Sie direkt in die Anweisungen des nächsten Falls hinein.
• Falls der Ausdruck bei switch ein Ergebnis liefert, das mit keiner der angegebenen Konstanten übereinstimmt, wird die Standardanweisung ausgeführt, die hinter default steht. Prinzipiell können Sie den default-Teil auch weglassen. Ich empfehle Ihnen aber nachdrücklich, bei jeder switch-Konstruktion einen solchen Anweisungsteil anzugeben. Selbst wenn Sie nicht erwarten, dass jemals der Ausdruck einen anderen als die vorgesehenen Werte annimmt, ist er Ihre Absicherung dafür, wenn es doch einmal passieren sollte. An dieser Stelle bietet sich dann die Ausgabe einer Fehlermeldung an, damit Sie gleich sehen, dass etwas mit Ihrem Programm nicht in Ordnung ist.

Generell gilt, dass sich switch-Anweisungen auch in geschachtelte if-Anweisungen umformen lassen. Umgekehrt ist dies natürlich nicht immer möglich, da bei switch ja nur Vergleiche mit ganzzahligen Ausdrücken erlaubt sind. Wenn Ihr Ausdruck also eine andere Form hat, zum Beispiel ein Textstring, dann müssen Sie doch geschachtelte if-Anweisungen verwenden. Der Nachteil an diesen ist, dass dabei unter Umständen sehr viele Vergleiche durchzuführen sind, was sich bei häufigerem Durchlauf durch diesen Programmteil negativ auf die Laufzeit der Anwendungen auswirken kann. Suchen Sie beispielsweise einen Namen, kann es zu folgendem Code kommen:

In einigen Fällen ist es möglich, durch Uminterpretation oder vorheriges Nachschlagen in einer Liste einem Textausdruck doch noch eine Ganzzahl zuzuordnen. In diesen Fällen sollten Sie dann auch vom switch-Konstrukt Gebrauch machen. Bei diesem Beispiel ist ein möglicher, wenn auch ziemlich unschöner Trick zur Uminterpretation, sich an den Anfangsbuchstaben der Damen zu orientieren, also etwa

Bei dieser Vorgehensweise bekommen Sie spätestens dann Probleme, wenn Sie weitere Fälle berücksichtigen müssen, die nicht durch Ihre Auswahl abgedeckt sind, beispielsweise eine Zulage von 200 für Angela. Der Weg über eine Listenauswahl ist da schon sicherer, wenn auch nicht immer elegant.

Beispiel: Auslesen von Kommandozeilenparametern

Bereits auf Seite 178 haben wir die Parameter, die der Anwender über die Kommandozeile an ein Programm übergeben kann, ausgewertet und angezeigt. Die Funktion main() kann über die Argumente argc und argv verfügen, wobei argc die Anzahl der Parameter ist (der Programmname zählt als erster Parameter) und argv ein Feld mit den eigentlichen Angaben. Nun wollen wir noch einen Schritt weitergehen und Optionen berücksichtigen, die aus einem Strich und einem Buchstaben, eventuell mit einem Argument dahinter, bestehen - wie etwa -o beim GCC.

Dazu können wir die Funktion getopt() aus der GNU-C-Bibliothek nutzen (dafür ist das Einbinden der Header-Datei unistd.h erforderlich). Diese ist ein sehr praktisches und elegantes Hilfsmittel, um Kommandozeilenoptionen auszuwerten (zu "parsen", wie der Fachmann sagt). Man übergibt ihr die beiden Parameter der main()-Funktion, also argc und argv, sowie eine Zeichenkette, in der die Buchstaben, die als Optionen erkannt werden sollen, aufgelistet sind. Falls hinter einer Option noch ein Argument folgen soll, muss hinter dem Buchstaben in der Zeichenkette ein Doppelpunkt stehen.

Über den Aufruf von getopt() wird immer ein Parameter ausgelesen und in der Variablen opt gespeichert. Darin steht entweder das Zeichen, das die Funktion gefunden hat, also der Buchstabe hinter dem Strich (etwa das "d" bei der Option -d), oder "?", wenn eine unbekannte Option verwendet wurde, oder -1, falls das Ende der Kommandozeile erreicht ist.

Normalerweise lassen sich Programme über Kommandozeilenoptionen konfigurieren oder zu einem bestimmten Verhalten veranlassen. Beim GCC etwa haben Sie dafür auf Seite 123 eine Reihe von Möglichkeiten gesehen. Hier wollen wir jedoch nur ein Übungsbeispiel erstellen. Darin soll ein Text ausgegeben werden, den der Benutzer hinter der Option -d (für "description") oder -t (für "text") angeben kann. Zusätzlich wollen wir eine Zeilen- oder Fehlernummer aufnehmen, die der Anwender anschließend an -l (für "line") oder -n (für "number") übergeben kann. Schließlich besteht noch die Möglichkeit, im Anschluss an die Textausgabe eine zusätzliche Leerzeile einzufügen, indem man die Option -s (für "space") wählt. Der Aufruf von getopt() lautet damit:

All diese Aspekte sind im nachfolgenden Programm enthalten. Um alle Optionen zu erfassen, musste ich noch eine Schleife einbauen. Wenn diese Sie irritiert, gedulden Sie sich bitte bis zum nächsten Abschnitt, wo deren Bedeutung genau erklärt wird.

Die Schleife über alle angegebenen Argumente in der Kommandozeile läuft von Zeile 27 bis Zeile 55. Wie erwähnt steht nach dem Aufruf von getopt() der ausgelesene Parameter in der Variablen opt. Der zugewiesene Wert gilt gleichzeitig als Ergebnis dieses Ausdrucks, so dass die Schleifenbedingung darauf warten kann, dass sich dabei eine -1 ergibt, was das Ende der Kommandozeile signalisiert.

In der switch-Anweisung (Zeile 30-54), um die es uns hier ja eigentlich geht, kommen gleich mehrere Varianten vor, wie sich die Fallunterscheidung realisieren lässt. Den Standardfall sehen Sie in den Zeilen 40 bis 43 für das Argument s: Auf die case-Anweisung folgen ein paar Befehle und dann sofort das break. Damit ist die Abarbeitung in diesem Fall hier beendet und das Programm fährt mit Zeile 55, also mit der Schleife fort.

Anders sieht es aus beim Argument d in Zeile 32/33. In diesem Fall wird zwar auch der Text "Argument d gegeben!" ausgedruckt; da aber das break fehlt, geht die Ausführung in der nächsten Zeile weiter. Somit erscheint zusätzlich die Ausgabe "Argument t gegeben!", bevor der Text hinter dem Parameter (enthalten in optarg) gespeichert und die Fallunterscheidung abgebrochen wird. Beachten Sie, dass es sich hierbei um ein erwünschtes Verhalten handelt. In Ihren Programmen sollten Sie eine solche Situation durch klare Kommentare kennzeichnen.

In Zeile 45 haben wir dann den Fall, dass nach einer case-Anweisung überhaupt keine weiteren Befehle, sondern gleich das nächste case folgt. Die Funktion atoi() (also "ASCII to integer") in Zeile 47 stammt übrigens aus der Standardbibliothek und wandelt eine Zeichenkette in eine Ganzzahl um.

Abschließend macht das Programm noch die Ausgabe, für die man es konfiguriert hat. Testen Sie doch ein paar Aufrufvarianten, um zu sehen, wie sich die Fallunterscheidung in verschiedenen Situationen verhält.

Hintergrund

Wenn Sie es irgendwann einmal mit Richtlinien zu tun bekommen, die Ihnen Vorschriften hinsichtlich des Designs Ihrer Programme machen, finden Sie darin eventuell auch den Hinweis, dass verschachtelte if-Anweisungen oder gar switch-Anweisungen vermieden werden sollten, da sie auf ein prozedurales (also nicht objektorientiertes) Denken hindeuten. Können Sie sich vorstellen, was damit gemeint sein könnte?

Betrachten wir als Beispiel eine Klasse Printer, die natürlich über eine (virtuelle) Methode print() verfügt. Zusätzlich habe sie ein Attribut typeId, mit der sich die Bauart bestimmen lässt. Sie habe die Unterklassen LaserPrinter, InkJet und Fax, die diese Methode entsprechend ihren Fähigkeiten implementieren.

Eine andere Klasse, etwa Document, will nun darüber einen Ausdruck vornehmen. Deren print()-Methode erhält über die Schnittstelle nach außen nur eine Referenz auf ein Printer-Objekt, muss dann aber selbst feststellen, was für ein Typ von Drucker das eigentlich ist, zum Beispiel so:

In diesem Codefragment drückt sich in der Tat aus, dass der Autor eine Klasse als nicht viel mehr als einen Datencontainer ansieht. Sehr viel sinnvoller wäre es da, jeder Klasse eine virtuelle Methode init() hinzuzufügen, die die notwendigen Vorverarbeitungsschritte durchführt. Dann lässt sich obige Operation nämlich ganz kurz schreiben:

Über den polymorphen Charakter des Arguments erkennt das Programm zur Laufzeit selbst, um welche Art von Drucker (sprich: Unterklasse) es sich handelt, und ruft dessen Methoden auf.

Obiges Beispiel zeigt die so genannte "Polymorphismus-Angst", die viele Einsteiger in die objektorientierte Programmierung haben. Wie Sie an der zweiten Version sehen, ist diese nicht nur unberechtigt, sondern auch hinderlich, da sie komplizierte Konstruktionen anstelle kurzer Aufrufe für erforderlich hält. Auf der anderen Seite heißt das aber nicht, dass sämtliche switch-Anweisungen auf diese Weise überflüssig werden können. Unser getopt()-Beispiel von vorhin beweist das Gegenteil.

3.1.3 Schleifen

Neben Bedingungen sind Schleifen die am häufigsten anzutreffenden Kontrollelemente für den Programmfluss. Immer wieder gibt es Aufgaben, die wiederholt werden müssen, bis eine bestimmte Bedingung erfüllt oder eine Höchstzahl an Wiederholungen erreicht ist. Die Sprache C++ bietet dazu dreierlei Arten von Schleifen, die eng miteinander verwandt sind.

Schleife mit Anfangsüberprüfung

Bei der ersten Form wird die Abbruchbedingung zuerst überprüft, bevor der Schleifenblock betreten wird. Die Syntax lautet:

Solange die Bedingung erfüllt ist, werden die Anweisungen innerhalb des Blocks immer und immer wieder ausgeführt (siehe linkes Diagramm in Abbildung 3.1 auf Seite 306). Mit "Bedingung" ist dabei wieder wie bei if ein Ausdruck gemeint, der einen ganzzahligen Wert ungleich 0 oder true ergeben muss, damit sie als erfüllt angesehen wird. Der Vorteil dieser Variante ist, dass die Bedingung schon vor der ersten Anweisung des Schleifenkörpers überprüft wird. Ist sie von Anfang an nicht erfüllt, wird der Block gleich ganz übersprungen.

Ebenso wie bei if darf auch hinter while nicht unmittelbar ein Semikolon folgen - sonst erkennt dies der Compiler als leere Anweisung und stürzt in eine Endlosschleife, wenn die Bedingung erfüllt ist und sich nicht selbst modifiziert (etwa durch einen Inkrementoperator).

Ein einfaches Beispiel ist der euklidische Algorithmus. Mit ihm berechnet man seit fast zweieinhalbtausend Jahren den größten gemeinsamen Teiler (ggT) zweier ganzer Zahlen. Eine Anwendung ist das Kürzen in der Bruchrechnung; dort ist es genau der ggT von Zähler und Nenner, mit dem man einen vollständig gekürzten Bruch erhält, indem man nämlich sowohl Zähler als auch Nenner durch den ggT dividiert.

Die Schleife läuft so lange, bis y null wird, also die Division im letzten Schritt aufgegangen war. Dann ist auch das letzte Ergebnis, derzeit gespeichert in x, der ggT.

Schleifen mit Überprüfung am Ende

Das Gegenstück zur Schleife mit Anfangsprüfung ist die Schleife mit do und while.

Auf das do folgt also wieder unmittelbar eine einzelne Anweisung oder ein Block. Der wesentliche Unterschied zur reinen while-Schleife besteht darin, dass bei dieser Form die Bedingung erst überprüft wird, wenn der Schleifenkörper schon einmal durchlaufen wurde. Er wird also immer mindestens einmal ausgeführt. Ansonsten kann man die beiden Schleifenformen immer ineinander umwandeln, braucht dabei aber unter Umständen zusätzliche Bedingungen.

Als Beispiel betrachten wir die Berechnung der Fläche unter einer Parabel. Diese lässt sich näherungsweise als Summe von Rechteckflächen auffassen, wobei die Höhen der Rechtecke vom Funktionswert abhängen, die Breite h aber konstant sein soll. Streng mathematisch ausgedrückt, berechnen wir also eine Näherung des bestimmten Integrals

for-Schleifen

Die drei Teile haben dabei folgende Bedeutung:

• Initialisierung: Hier können Sie Startwerte setzen, zum Beispiel die Laufvariable mit einem Anfangswert versehen. Dieser Teil wird nur einmal zu Beginn abgearbeitet.
• Bedingung: Die Schleife wird ausgeführt, solange die angegebene Bedingung erfüllt ist (das heißt der Ausdruck einen Wert ungleich null liefert).
• Anpassung: Nach jeder Ausführung des Anweisungsblocks können Sie hier Schleifenparameter anpassen (erhöhen, vermindern und so weiter).

Beachten Sie aber, dass keiner dieser drei Teile zwingend ist. Jeder davon kann auch leer bleiben. (Im Extremfall auch alle drei - dann haben Sie eine Endlosschleife!)

Der Standardfall ist das Hochzählen einer Schleifenvariablen innerhalb fester Grenzen, etwa

(Achtung: Wenn Sie keinen Block mit geschweiften Klammern { und } verwenden, erstreckt sich die Wiederholung nur auf eine einzige Anweisung. Alle Folgenden werden dann wieder nur einmal ausgeführt.) Sie sehen an diesem Beispiel gleich noch eine weitere Besonderheit: Die Zählvariable muss nicht unbedingt schon vorher deklariert sein; Sie können sie auch noch innerhalb des Initialisierungsteils der Schleife deklarieren. Bei älteren Compilern ist sie dann auch am Ende der Schleife noch gültig. Nach dem neuen ANSI-Standard ist dies indessen nicht der Fall. Der GCC erkennt diese Situation, wenn Sie versuchen, hinter der Schleife die Variable noch zu verwenden. Er unterrichtet Sie davon mit den Fehlermeldungen "name lookup of ‘i’ changed for new ISO ‘for’ scoping" sowie "using obsolete binding at ‘i’".

Betrachten wir noch eine etwas extremere Verwendung (auf ein paar weitere gemäßigte Anwendungen werden Sie im Laufe des Buches ohnehin noch stoßen). Nehmen wir an, wir hätten eine Klasse vector, die einen Vektor mit gleichartigen (der Einfachheit halber ganzzahligen) Elementen repräsentiert, eine Zugriffsmethode vector::at(int i) auf das i-te Element und eine Methode vector::size(), welche die Anzahl der Elemente zurückliefert. Dann können wir die Summe aller Elemente unter anderem wie folgt berechnen:

Wenn Sie nicht gleich verstehen, was hier vor sich geht, ist das auch nicht weiter schlimm. Versuchen Sie am besten, die Aufgabe der Summenberechnung unabhängig davon selbst zu lösen und vergleichen Sie Ihren Ansatz dann mit diesem.

Das Beispiel zeigt Ihnen noch ein Problem, das der Sprache C++ generell anhaftet und weshalb sie auch nicht gerade zu den leichtesten und praktikabelsten zählt. Viele Anweisungen können Sie auf viele verschiedene Arten benutzen, von übersichtlich bis unleserlich. Auch dieser Code ist syntaktisch durchaus korrekt, wenngleich es ein schwer verständlicher Stil ist. Um Ihrer eigenen und der Nerven Ihrer Kollegen willen: Achten Sie stets darauf, lesbaren Code zu schreiben, den Sie und andere auch noch nach einiger Zeit verstehen können. Im Streben nach Eleganz und Kompaktheit geht die Lesbarkeit leider zu häufig unter.

Doch zurück zu den for-Schleifen: Sicher ist Ihnen mittlerweile klar, dass es sich bei diesen auch nur um Spezialfälle der while-Schleifen handelt; das bedeutet, beide Formen sind äquivalent und können stets ineinander umgewandelt werden. Im Allgemeinen hängt es daher vom Kontext ab, welche Form man wählt. Ist die Anzahl der Wiederholungen bekannt, greift man lieber zu for; ist die Abbruchbedingung nicht unmittelbar an die Zahl der Durchläufe gekoppelt, verwendet man eher while. Versuchen Sie doch mal, obige Beispiele als while-Schleifen zu schreiben.

Schleifenkontrolle

Manchmal werden Sie verhindern wollen, dass tatsächlich jede Iteration einer Schleife durchlaufen wird. Das kann zum einen der Fall sein, wenn eine Abfrage zwischendrin ergibt, dass ein weiterer Durchlauf nicht mehr möglich ist oder keinen Sinn mehr machen würde; dann wollen Sie die Wiederholung ganz abbrechen. Eine andere Möglichkeit besteht darin, dass Sie bei einem Durchlauf feststellen, dass Sie den Rest des Schleifenkörpers gar nicht mehr abarbeiten können oder wollen, aber trotzdem mit der nächsten Iteration fortfahren möchten. Für beide Fälle bietet C++ entsprechende Befehle.

Für die erste Aufgabe gibt es die break-Anweisung, die wir schon bei der Mehrfachauswahl kennen gelernt haben. Innerhalb einer Schleife bewirkt sie, dass die Abarbeitung des Schleifenkörpers unmittelbar abgebrochen wird und das Programm beim nächsten Befehl hinter der Schleife fortfährt. Natürlich werden Sie nie diese Anweisung in Ihr Programm schreiben, ohne sie von einer Bedingung abhängig zu machen. Zuweilen will man etwa eine bestimmte Anzahl von Objekten auf eine Eigenschaft durchsuchen und schreibt dazu eine for-Schleife; wenn ein Objekt mit der gewünschten Eigenschaft gefunden wurde, kann die Suche abbrechen - denn warum sollte man noch weitere Iterationen durchlaufen, wenn das Ziel schon erreicht wurde?

Dazu ein einfaches Beispiel: Sie wissen, dass irgendeine Zahl unter zwanzig als dritte Potenz 1728 ergibt. Leider kann Ihr Taschenrechner aber keine dritten Wurzeln berechnen und daher lassen Sie Ihren Computer probieren. Sobald die gesuchte Zahl ermittelt wurde, darf die Suche abbrechen.

Kleines Quiz am Rande: Wie können Sie überprüfen, ob überhaupt ein i gefunden wurde, das die Bedingung erfüllt?

Die andere Variante erreichen Sie mit der continue-Anweisung. Sie bewirkt, dass der Rest des Schleifenkörpers übersprungen und die Ausführung mit der nächsten Iteration fortgesetzt wird. Auch diese Anweisung werden Sie stets in Abhängigkeit von einer Bedingung verwenden. Sie bietet sich beispielsweise an, wenn Sie mit allen Elementen einer Menge eine bestimmte Operation durchführen wollen, nur mit einem nicht. Wenn Sie etwa die Funktion f(x) = im Bereich von -10 bis 10 mit Schrittweite 1 ausgeben wollen, können Sie schreiben:

denn bei 0 ist die Funktion ja nicht definiert.

Beide Anweisungen zur Schleifenkontrolle können Sie bei allen drei oben besprochenen Typen verwenden.

3.1.4 Zusammenfassung

Aus diesem Abschnitt sollten Sie sich Folgendes merken:

• Bedingungen werden in C++ durch die if-Anweisung ausgedrückt. Hinter dieser folgt eine einzelne Anweisung oder ein Block. Anweisungen für den Fall, dass die Bedingung nicht erfüllt ist, können in einem else-Teil angegeben werden. Auch sind Verschachtelungen von Bedingungen möglich.
• In der Bedingung müssen Sie die Überprüfung auf true beziehungsweise ungleich 0 nicht explizit hinschreiben. Eine Formulierung in der Form if(variable) ... ist ebenso zulässig.
• Die häufigsten Fehler bei if-Anweisungen sind die falsche Schreibweise des Gleichheitsoperators als Zulassungsoperator (ein = wird vergessen), ein überflüssiges Semikolon hinter der Bedingung, Mehrdeutigkeiten durch falschen Schreibstil bei Verschachtelungen sowie die gemischte Verwendung von int und unsigned in einer Bedingung.
• Durch die switch-Anweisung kann eine Auswahl unter mehreren getroffen werden. Dabei muss allerdings der Ausdruck ein Ergebnis haben, das nach int umwandelbar ist. Sein Resultat wird dann mit den bei case angegebenen Konstanten verglichen. Ein Fall default ist zwar optional, sollte aber immer angegeben werden.
• Fehlt die break-Anweisung, mit der der switch-Block verlassen wird, werden alle weiteren Anweisungen bis zum nächsten break oder dem Ende des Blocks ausgeführt.
• Mit while erstellen Sie eine Schleife, in der die Bedingung zu Beginn jedes Durchlaufs überprüft wird. Ist sie schon beim ersten nicht erfüllt, wird der Schleifenkörper erst gar nicht betreten. Die gegenteilige Überprüfung erreichen Sie mit der do/while-Kombination, bei der am Ende einer Iteration die Bedingung geprüft wird.
• Die for-Schleife beinhaltet die drei Teile Initialisierung, Bedingung und Anpassungsanweisung. Von diesen darf aber auch jeder Teil leer bleiben. Diese Schleifen lassen sich stets auch in while-Schleifen umformulieren.
• Die break-Anweisung in einer Schleife bewirkt, dass diese bei Erreichen abgebrochen wird. Dagegen sorgt die continue-Anweisung dafür, dass der Rest des Schleifenkörpers übersprungen und die Ausführung bei der nächsten Iteration fortgesetzt wird.

3.1.5 Übungsaufgaben

1. Welche Ausgabe hat folgender Programmausschnitt:
   int i, x=0;

   for (i=0; i<10; i++)

     x += i;

   cout << x << `` `` << i << endl;

2. Implementieren Sie ein Verfahren zur Berechnung der Kubikwurzel für beliebige positive reelle Zahlen. Testen Sie es an Beispielen.
3. Der Geistliche Christoph Zeller hat 1885 eine Formel aufgestellt, mit der sich für ein gegebenes Kalenderdatum der Wochentag berechnen lässt. Sie lautet: Dabei ist t der Tag des Monats (zwischen 1 und 31), m der Monat selbst (1 bis 12, wobei Januar und Februar als Monate 13 und 14 des Vorjahres eingesetzt werden müssen), j das Jahr im Jahrhundert (also zwischen 0 und 99) sowie h das Jahrhundert (zweistellig, z.B. 19 oder 20). Alle Divisionen sind dabei rein ganzzahlig zu verstehen.

   Schreiben Sie ein Programm, das drei Zahlen von der Kommandozeile einliest, nämlich Tag, Monat und Jahr. Anschließend soll es den Wochentag als ausgeschriebenes deutsches Wort ausgeben. In der Formel steht dabei 0 für Sonntag, 1 für Montag usw.

4. Schreiben Sie ein C++-Programm, das ermittelt, wann ein Freitag auf den 13. eines Monats fällt. Überlegen Sie sich, von welchem Parameter es abhängt, in welchem Monat ein Freitag, der 13. auftritt. Ihr Programm soll für alle Möglichkeiten auflisten, in welchem Jahr wie viele Freitage, der 13. auftreten und in welche Monate sie fallen.

   Hinweis: Da das zu lösende Problem vom ersten Tag des Jahres abhängt, können nur sieben verschiedene Fälle in Betracht kommen. Berücksichtigt man noch die Existenz von Schaltjahren, verdoppelt sich die Anzahl der zu untersuchenden Fälle.

5. Die Fibonacci-Zahlen sind eine rekursiv definierte Zahlenfolge. Dabei ist F₀ = 0, F₁ = 1 und F_n = F_n-1 + F_n-2. Damit kann man beispielsweise das Wachstum einer Tierpopulation gut annähern. Schreiben Sie eine C++-Funktion, welche die Zahl n als Parameter übergeben bekommt und die dann alle Fibonacci-Zahlen F₁,...,F_n berechnet und ausgibt. Testen Sie die Funktion auf geeignete Weise.
6. Welche Probleme verbergen sich in folgenden Schleifen:
   1. while (i¿0) k *= 2;
   2. while (i!=0) i -= 2;
   3. while (n!=i) n = 2*++i;

7. Die Zahl kann unter anderem durch die folgende unendliche Reihe berechnet werden: Schreiben Sie ein C++-Programm, das die Zahl approximiert, indem Sie immer einen weiteren Term dieser Reihe hinzunehmen. Formulieren Sie Ihr Programm sowohl mit einer for-Schleife als auch mit einer do-Schleife, die mit break abbricht, wenn die gewünschte Genauigkeit erreicht ist.
8. Pythagoräische Tripel sind jeweils drei ganze Zahlen (a,b,c), die die Gleichung a² + b² = c² erfüllen, z.B. (3,4,5). Schreiben Sie ein Programm, das alle pythagoräischen Tripel findet, für die a + b + c < 500 gilt.
9. Ein sehr einfaches Verfahren, um Texte zu verschlüsseln, ist die Caesar-Chiffrierung. Dabei wird jeder Buchstabe des Eingabetextes durch den Buchstaben ersetzt, der in einem festgelegten Abstand dahinter im Alphabet steht. Wir wollen dabei nur Groß- und Kleinbuchstaben von A bis Z bzw. a bis z verschlüsseln, keine Umlaute oder Sonderzeichen. Falls die Verschiebung über Z bzw. z hinaus geht, soll wieder bei A bzw. a begonnen werden.

   Schreiben Sie eine Klasse Caesar, die diese Chiffrierung implementiert. Dabei soll der Abstand als Argument dem Konstruktor übergeben werden. Fehlt dieser Parameter, soll als Vorgabewert 6 angenommen werden. Die Klasse soll zudem über eine Methode

   char Caesar::encode(char _input)

   verfügen, die ein unverschlüsseltes Zeichen erhält und das verschlüsselte Gegenstück zurückliefert. Außerdem soll natürlich noch das Pendant Caesar::decode() verfügbar sein. Testen Sie Ihre Klasse an einem Beispiel, das mittels std::cin über die Tastatur vom Benutzer eingegeben wird.

3.2 Dateien und Ströme

Eine der wichtigsten Möglichkeiten, um Daten auch über das Ende eines Programms hinaus zu erhalten oder mit anderen auszutauschen, sind Dateien. Die C++-Standardbibliothek bietet zur Arbeit mit Dateien eine umfangreiche Liste von Klassen an, mit denen Sie Dateien anlegen, lesen, beschreiben und ergänzen können.

3.2.1 Standardein- und -ausgabe

An vielen Stellen in diesem Buch habe ich bereits die Standardkanäle für die Ein- und Ausgabe verwendet. Daher wird es Zeit, dass Sie verstehen, um was es sich dabei eigentlich handelt. Dazu müssen wir uns aber zunächst anschauen, woher unsere Daten eigentlich kommen und wohin wir sie schicken.

Unter Unix kann ein Programm Eingaben eines Benutzers (Namen, Zahlen und so weiter) von der so genannten Standardeingabe lesen. Das ist im Normalfall die Tastatur. Wenn Sie das Programm aus der Shell aufrufen, können Sie aber auch die Standardeingabe umlenken und alles aus einer anderen Datei holen, was sonst ein Benutzer eingeben müsste. Haben Sie etwa ein Programm protect, das die Eingabe eines Benutzernamens erfordert, können Sie auch (etwa mit vi) eine kleine Datei erstellen, die nur aus diesem Namen und einem anschließenden Zeilenumbruch (newline) besteht. Nennen wir diese beispielsweise kennung.txt. Dann erfolgt der Aufruf folgendermaßen (C-Shell):

In C++ sind diese Kanäle durch Ströme (streams) repräsentiert. Das sind Objekte, die eine Folge von Bytes liefern beziehungsweise aufnehmen und ausgeben können. Der Standardeingabe ist der Stream cin zugeordnet. Um die Metapher vom Fluss noch zu unterstreichen, verwendet man für die Eingabe den Operator ¿¿. Dahinter geben Sie dann die Variable an, die die Eingabe aufnehmen soll. Anhand des Typs erkennt der Stream, wie er die Bytefolge interpretieren soll. Es werden so lange Zeichen akzeptiert, bis der Benutzer die Eingabetaste drückt. In folgendem Beispiel wird eine Ganzzahl abgefragt. Stehen mehrere in einer Zeile, getrennt durch Leerzeichen, hintereinander, so wird die erste davon nach x geschrieben.

Um die in diesem Abschnitt beschriebenen Streams zu verwenden, müssen Sie die Header-Datei iostream in Ihr Programm einbinden.

Für die Ausgabe gibt es den entgegengesetzten Operator ¡¡. Auch hier können Sie sich vorstellen, dass der Operator in die Richtung zeigt, in die die Bytes geschickt werden sollen. Das Besondere an diesem Operator ist zum einen, dass er für alle Standardtypen definiert ist und Sie sich damit nicht darum kümmern müssen, die Daten für die Ausgabe zu formatieren. Zum anderen ist es sehr praktisch, dass mehrere Ausgaben unterschiedlichen Typs miteinander verkettet werden können, wie wir es ja bereits mehrfach verwendet haben, etwa zuletzt auf Seite 310. Wenn Sie die Ausgabe so verketten, werden alle auszugebenden Zeichen hintereinander gefügt; um trennende Leerzeichen und so weiter müssen Sie sich natürlich selbst kümmern. Um einen Zeilenumbruch einzufügen, schicken Sie endl in den Stream, einen so genannten Manipulator, der kein Zeichen im eigentlich Sinn ist, sondern nur auf das Format der Ausgabe Einfluss nimmt. Der Stream für die Standardausgabe hat übrigens den Namen cout.

Ebenso wie die Standardeingabe ist auch die Standardausgabe ein fest definierter Begriff unter Unix. Das ist der Text, den das Programm während seines Laufs in das Shell-Fenster schreibt. Manchmal möchte man die Ausgabe aber lieber in einer Datei haben. Dazu gibt es auch hier die Möglichkeit, den Kanal in eine Datei umzulenken. Das können Sie schon mit einem einfachen Kommando wie ls ausprobieren. Wenn Sie eingeben:

erhalten Sie überhaupt keine Ausgabe auf dem Bildschirm, sondern finden anschließend eine Auflistung aller Dateien des aktuellen Verzeichnisses in der Datei verzeichnis.txt.

Eine Möglichkeit, die Umlenkung von Aus- und Eingabe in der Shell zu verbinden, ist der Pipe-Mechanismus mit dem Zeichen --. Damit erreichen Sie, dass die Standardausgabe des ersten in die Standardeingabe des zweiten Programms umgeleitet wird. Eine häufige Anwendung ist das Zusammenspiel von cat, das einfach eine Datei auf die Standardausgabe schickt, und grep, das aus der Standardeingabe alle Zeilen herausfiltert, die ein bestimmtes Muster oder einen Suchbegriff enthalten. Suchen Sie in Ihrer Quelltextdatei prog.cc beispielsweise alle Stellen, an denen Sie das Objekt Konfiguration verwendet haben, so können Sie schreiben:

Wenn Sie nun aber alle Ausgaben Ihres Programms in eine Datei umgelenkt haben, bekommen Sie auch die Fehlermeldungen nicht mit - sollte man meinen. Da dies aber sicher nicht hilfreich ist, gibt es noch einen zweiten Kanal, über den Sie Ausgaben vornehmen können: die Standardfehlerausgabe. Diese sprechen Sie als cerr (oder auch clog, was fast dasselbe ist) an. Ohne Umlenkung bemerkt der Benutzer des Programms gar nicht, dass es sich um zwei getrennte Ausgabewege handelt, da beide auf den Bildschirm schreiben. Erst wenn die Standardausgabe umgelenkt wird und immer noch Text auf dem Bildschirm erscheint, wurde dieser sicherlich in den Fehlerausgabekanal geschrieben. Wenn Sie Textausgaben programmieren, sollten Sie sich also stets überlegen, ob Sie eine Nachricht ausgeben wollen, die bei korrektem Programmablauf erscheinen soll, oder eine Fehlermeldung. Im letzteren Fall sollten Sie dazu cerr verwenden.

Wenn Programme im Hintergrund oder im Batch-Betrieb laufen, ist eine Bildschirmausgabe meist nicht sinnvoll, oft sogar unmöglich. Daher sollten Sie in einer solchen Situation beide Ausgabekanäle umleiten. Die Syntax der Shell-Anweisung dafür variiert von Shell zu Shell ein wenig. In der C-Shell etwa verwendet man die Zeichen ¿&. Wenn Sie zum Beispiel alle Ausgaben des find-Kommandos, das nach C++-Quelltextdateien sucht, in eine Datei namens gefunden.txt speichern wollen, geben Sie ein:

Auf diese Weise wird eine Bildschirmausgabe vollständig unterdrückt.

3.2.2 Ein- und Ausgabe mit Dateien

Für die Arbeit mit Dateien stehen eine Reihe von Klassen in der C++-Standardbibliothek zur Verfügung. Für den Programmierer besonders relevant sind dabei:

• Die Klasse ofstream für die Ausgabe in eine Datei
• Die Klasse ifstream für die Eingabe aus einer Datei
• Die Klasse fstream für Ein- und Ausgabe

Wenn Sie also auf eine Datei zugreifen wollen, müssen Sie ein Objekt einer dieser Klassen anlegen. Damit der Compiler die Klassen auch kennt, binden Sie die Header-Dateien iostream und fstream ein, am besten gleich gefolgt von einer obligatorischen Deklaration des Standardnamensraums (siehe auch Seiten 164 und 401), also etwa:

Öffnen der Datei

Zum Öffnen einer Datei gibt es zwei Möglichkeiten. Zur Identifikation dient in beiden Fällen der Dateiname.

1. Entweder Sie geben den Namen gleich als Argument des Konstruktors an. Dann wird das Öffnen der Datei zusammen mit der Erzeugung der Instanz erledigt, beispielsweise:
     ofstream outfile(``results.dat'');

2. Wenn Sie schon ein Objekt haben und über dieses eine Datei öffnen möchten, so können Sie die Methode open() verwenden. Diese verlangt ebenfalls den Dateinamen als Argument.
     ifstream infile;

     infile.open(``myfile.txt'');

Zuweilen müssen Sie auch angeben, was Sie mit der Datei vorhaben. Denn davon hängt es ab, wo der Dateizeiger positioniert wird. Das Betriebssystem merkt sich nämlich stets, an welcher Stelle in der Datei Sie gerade stehen, das heißt, wohin als Nächstes geschrieben beziehungsweise von wo als Nächstes gelesen wird. Daneben gibt es noch ein paar weitere Modi, in denen Sie Dateien bearbeiten können. Um einen solchen festzulegen, können Sie dem Konstruktor oder der open()-Methode noch ein zusätzliches Argument mitgeben. Unter anderem können Sie die Spezifizierer aus Tabelle 3.1 verwenden.

Hier noch eine wichtige Anmerkung: Der ANSI/ISO-Standard schreibt vor, dass die Basisklasse aller Stream-Klassen den Namen ios_base hat. Leider ist die Implementierung der C++-Standardbibliothek erst ab GCC 3.0 so weit, dass sie dies berücksichtigt. In früheren Versionen heißt die Basisklasse noch ios. Wenn Sie also einen älteren Compiler verwenden, muss es bei Ihnen im Folgenden überall dort, wo hier ios_base steht, dann schlicht ios lauten.

Bei Ausgabedateien ist die Voreinstellung so festgelegt, dass sie geöffnet werden und ihr eventuell schon vorhandener Inhalt gelöscht wird. Wenn Sie also an das Bestehende anhängen möchten, müssen Sie ios_base::app angeben.

Wollen Sie mehrere dieser Spezifizierer gleichzeitig angeben, müssen Sie sie durch eine ODER-Verknüpfung mittels "--" miteinander verbinden, zum Beispiel:

Schließen einer Datei

Wenn wir nun schon die Datei geöffnet haben, sollten wir sie der Ordnung halber eigentlich wieder schließen, wenn wir sie nicht mehr brauchen. Zum Glück weiß aber ein Stream-Objekt, ob mit ihm eine geöffnete Datei verbunden ist; wird das Stream-Objekt zerstört, das heißt, wird sein Destruktor aufgerufen, schließt es selbstständig die Datei. Daher müssen Sie sich also nur dann selbst um das Schließen kümmern, wenn Sie dasselbe Stream-Objekt nochmals anderweitig verwenden wollen.

In diesem Beispiel endet mit der abschließenden geschweiften Klammer der Funktionskörper und damit die Lebenszeit des Objekts resfile. Es wird also dessen Destruktor aufgerufen, in dem auch die Datei results.log geschlossen wird.

Wenn Sie das Schließen selbst übernehmen wollen, rufen Sie dazu die Methode close() auf.

Ein- und Ausgabe

Für die Standarddatentypen wie int, char oder float stellt die C++-Standardbibliothek die Operatoren “¿¿” sowie “¡¡” zur Ein- und Ausgabe zur Verfügung, die Sie genauso verwenden wie bei der Tastatureingabe beziehungsweise der Bildschirmausgabe. Beachten Sie dabei, dass beim Einlesen Trennzeichen wie Leerzeichen, Tabulator oder Zeilenumbruch standardmäßig überlesen werden.

Zur Ein- und Ausgabe von Objekten Ihrer eigenen Klassen können Sie die Operatoren auch überladen. Ein Beispiel dazu finden Sie auf Seite 562.

Generell können Sie mehrere Operatoren hintereinander hängen und die Ausgabe durch Kontrollstrukturen steuern. Wollen Sie beispielsweise die Ergebnisse einer Funktion f() an den Stellen 1 bis 10 in eine Datei schreiben, brauchen Sie dazu den Code:

Sie wundern sich sicher, was das \t in der Ausgabe zu bedeuten hat. Es handelt sich dabei um ein Relikt aus C-Zeiten, zu dem man leider gezwungen ist, da nicht alle Sonderzeichen in Form von Manipulatoren wie endl verfügbar sind. Mit \t etwa fügen Sie einen horizontalen Tabulator in die Ausgabe ein. Eine solche Zeichenkombination nennt man auch Escape-Sequenz. Weitere nützliche Steuersequenzen sind:

Möchten Sie nur einzelne Zeichen einlesen, sollten Sie die Methode get() verwenden, die auch in mehreren überladenen Versionen für die Standarddatentypen vorliegt. Sie empfiehlt sich vor allem bei binären Dateien; Sie können damit auf jedes Byte einzeln zugreifen, da sie auch Trennzeichen liest.

Die entsprechende Schreibmethode heißt put(). Auf diese Weise lässt sich auch eine Kopierfunktion realisieren:

Wollen Sie hingegen ganze Zeilen aus einer Textdatei einlesen, sollten Sie zur Funktion getline() greifen. Dabei werden alle Zeichen von der aktuellen Position des Dateizeigers bis zum Zeilenende eingelesen. Das Zeilenende ist dabei durch ein Newline ("\n") gekennzeichnet.

Dazu müssen Sie natürlich die Header-Datei string in Ihr Programm einbinden.

Fehlerbehandlung

Die Arbeit mit Dateien ist ein sensibler Bereich, der für die Robustheit eines Programms ausschlaggebend sein kann und in dem Sie daher keinesfalls auf Fehlerabfragen verzichten sollten. Zu viel kann schief gehen: Die Datei, die Sie öffnen möchten, kann nicht vorhanden sein, das Verzeichnis, in das Sie schreiben wollen, ebenso wenig und so weiter. Unter Unix stellt sich zudem im Vergleich zu Windows die Frage nach den Zugriffsrechten drängender. Der Fall, dass ein Verzeichnis zwar existiert, der Prozess dort jedoch nicht schreiben darf, ist gar nicht so selten. Und schließlich dürfen Sie auch in Zeiten ausufernder Festplattengrößen die Möglichkeit nicht außer Acht lassen, dass Sie beim Schreiben an die Grenze der Kapazität stoßen.

Ein sehr einfacher und eleganter Weg ist die Abfrage des Status eines Datei-Streams über das Objekt selbst. Es liefert nämlich 0 zurück, wenn ein Fehler aufgetreten ist.

Kein Fehler im eigentlichen Sinn, aber doch ein Zustand, auf den Sie achten sollten, ist das Erreichen des Dateiendes beim Lesen. Auch diese Situation können Sie über das Objekt abfangen:

Das bedeutet: Die Schleife läuft so lange, bis das Ende der Datei erreicht ist, denn dann wird die while-Bedingung gleich 0.

Für eine genauere Fehlererkennung bieten Ihnen die Stream-Klassen einige spezielle Methoden. Die wichtigsten davon sind:

• fail(), das bei fehlerhafter Ein-/Ausgabe, bei ungültiger Operation und bei sonstigen nicht behebbaren Fehlern einen Wert ungleich 0 liefert, sowie
• eof(), das am Dateiende ungleich 0 zurückgibt (end of file).

Obige Schleife heißt damit etwa:

Als kleines Beispiel betrachten wir ein Programm, das die Anzahl der Zeilen einer Textdatei ermittelt. Unter Linux brauchen wir ein solches Werkzeug eigentlich nicht, da das Kommando wc bereits diese Aufgabe erfüllt. Aber zur Illustration ist es sicher ganz hilfreich.

3.2.3 Positionierung des Dateizeigers

Wenn Sie eine Datei öffnen (und kein zusätzliches Argument dabei angegeben haben), steht der Dateizeiger ganz am Anfang. Besonders bei binären Dateien, in denen die Daten Byte für Byte unmittelbar hintereinander kommen und die für uns nicht ohne weiteres lesbar sind, kann es wichtig sein, den Dateizeiger an eine andere Stelle zu versetzen. Aber auch bei Textdateien, die im ASCII-Code gespeichert sind und die wir daher lesen können, will man manchmal an eine bestimmte Stelle springen - und sei es nur an den Anfang oder das Ende.

Um in einer Datei an eine bestimmte Position zu gelangen, verwenden Sie die Methoden ostream::seekp() in einer Ausgabedatei und istream::seekg() in einer Eingabedatei. Die aktuelle Position des Dateizeigers können Sie mit Hilfe von ostream::tellp() beziehungsweise istream::tellg() bestimmen. Deren Ergebnisse können Sie später als Sprungadressen verwenden.

Sie können aber auch relativ springen, das heißt eine bestimmte Anzahl von Bytes gerechnet ab Anfang oder Ende der Datei oder ab der aktuellen Position.

Die seek-Methoden benötigen folgende Parameter:

• Die Anzahl an Bytes, um die der Dateizeiger verschoben werden soll; eine positive Zahl verschiebt dabei in Richtung des Dateiendes, eine negative zum Dateianfang.
• Die Startposition der Positionierung; für diesen Offset gibt es drei symbolische Konstanten:
  • ios_base::beg (ab Anfang des Streams)
  • ios_base::cur (ab der aktuellen Position)
  • ios_base::end (ab dem Ende des Streams)

In folgendem Beispiel springen wir zunächst ans Dateiende. Wenn wir dort tellg() aufrufen, entspricht dieser Wert genau der Größe der Datei. Anschließend verschieben wir den Dateizeiger in die Mitte der Datei.

Hintergrund

Der Grund, dass wir so leicht zwischen verschiedenen Positionen einer Datei hin- und herspringen können, liegt darin, dass der Zugriff intern zwischengepuffert wird. Bei Ausgabedateien werden die Zeichen zunächst nur in den Puffer geschrieben. Erst wenn er voll ist oder der Stream geschlossen wird, erfolgt das tatsächliche Schreiben in die Datei. Dieses Verhalten zeigen übrigens auch die Standardstreams wie cout und clog.

Das kann manchmal unerwünschte Nebeneffekte haben. So geht man bei der Fehlersuche in größeren Programmen oft so vor, dass man zwischen den einzelnen Schritten jeweils eine Meldung mit cout ausgibt. Bricht das Programm ab, weiß man in etwa, wie weit es gekommen ist. Aufgrund der Pufferung kann es dabei jedoch vorkommen, dass die letzten Ausgaben vor dem Absturz gar nicht mehr auf dem Bildschirm erscheinen, da sie nur im Puffer standen und noch nicht rausgeschrieben wurden. Somit sucht man zuweilen den Fehler an einer völlig falschen Stelle.

Um das zu verhinden, sollten Sie bei solchen Ausgaben stets das sofortige Leeren des Puffers erzwingen. Dazu dienen sowohl der Manipulator flush als auch die Methode flush(). Ersterer ist meist eleganter, da er sich nahtlos in die übrigen Ausgaben einreiht.

3.2.4 Ausgabeformatierung

Vielfach wird Ihnen die Form, in der die eingebauten Operatoren Ihre Daten ausgeben, unbefriedigend erscheinen. Aber auch dafür bieten die C++-Streams Möglichkeiten der Einflussnahme an, etwa damit Sie eine Ausgabe im vorgegebenen Zahlenformat oder als Tabelle mit fester Spaltenbreite erreichen. Einige der wichtigsten Formatierungsbefehle will ich Ihnen im Folgenden vorstellen.

Auffüllen auf vorgegebene Breite

Mit Hilfe der Methode width() der Ausgabeklassen können Sie die Breite der unmittelbar folgenden Ausgabe festlegen. Falls also die Ausgabe weniger Zeichen liefert als angegeben, werden die übrigen Plätze durch Leerzeichen aufgefüllt. Wenn Ihnen das Leerzeichen nicht gefällt, können Sie mit fill() andere Füllzeichen festlegen. Ein Beispiel:

Diese Befehle führen zur Ausgabe: 00047--11--. Dabei zeigt sich eine wichtige Eigenschaft der width()-Methode: Sie wirkt immer nur auf die unmittelbar darauf folgende Ausgabe! Für die Ausgabe der 11 in der vierten Zeile gilt wieder der Vorgabewert 0.

Dasselbe Resultat können Sie übrigens auch mit Manipulatoren erreichen. Dazu müssen Sie die Header-Datei iomanip in Ihr Programm einbinden. Dann können Sie die Breite der folgenden Ausgabe mit setw() (von set width) bestimmen. Das ist dann keine Methode der Klasse ostream, sondern wird unmittelbar zwischen zwei Ausgabeoperatoren eingefügt. Analog dazu gibt es den Manipulator setfill(), um das Füllzeichen zu ändern. Das Beispiel von eben hieße damit:

Die Ausgabe ist wiederum dieselbe. Beachten Sie, dass auch hierbei die Manipulatoren nur auf die unmittelbar folgende Ausgabe wirken und in der nächsten schon wieder die Vorgabewerte wirksam sind. Intern werden nämlich auch bei dieser Schreibweise lediglich die obigen Methoden aufgerufen.

Genauigkeit von Gleitkommazahlen

Die Anzahl der Ziffern von Gleitkommazahlen wird mit precision() gesteuert. Anders als bei der Breite gilt diese Festlegung dauerhaft, das heißt bis zum nächsten Aufruf von precision(). Wenn die interne Darstellung mehr Ziffern enthält, wird die Ausgabe passend gerundet.

Auch hier haben Sie die Möglichkeit, die Einstellung der Ziffern über einen Manipulator vorzunehmen, genauer gesagt über setprecision(). Da dieser intern auf die gerade beschriebene Methode zurückgeführt wird, gelten auch dessen Einstellungen bis auf weiteres.

Besonders bei wissenschaftlichen Anwendungen gibt man die Ergebnisse oft in der so genannten Exponentialdarstellung aus, also als x ^. 10ⁿ oder kurz xe + n. Um eine solche Ausgabe zu erreichen, müssen Sie das Flag ios_base::scientific setzen. Dann stellen Sie mit precision() die Zahl der Nachkommastellen ein.

Weitere Ausgabeflags

Über die Methode setf der Stream-Klassen können Sie außer der Exponentialdarstellung noch weitere Ausgabeeigenschaften beeinflussen. Dazu stellt ios_base weitere Flags bereit. Tabelle 3.2 zeigt entsprechende Flags.

Wenn Sie mehrere dieser Flags gleichzeitig setzen wollen, können Sie sie wieder mit -- verknüpfen. Ein Löschen eines oder mehrerer Flags ist mit unsetf() möglich.

3.2.5 Beispiel: Umrechnung Dollar - Euro

Als Beispiel wollen wir eine kleine Tabelle erzeugen, die uns die immer noch nötige Umrechnerei von Dollar in Euro und zurück noch einmal vor Augen führen soll. Unsere Tabelle soll dabei von 1 bis 1000 reichen, wobei in jeder Zehnerpotenz immer nur die ersten fünf ganzen Vielfachen ausgegeben werden sollen, also 1, 2, 3, 4, 5, 10, 20 und so weiter - die Beschreibung ist komplizierter als das Programm ... Außerdem sollen alle Zahlen auf zwei Nachkommastellen formatiert werden und die Spalten sollen dieselbe Breite haben. Bevor Sie nun die nachfolgende Musterlösung durchgehen, sollten Sie versuchen, selbst ein Programm zu schreiben, das diese Aufgabe erfüllt.

Den Wechselkurs legen wir als Konstante in Zeile 9 fest. Sie können diese Zahl selbstverständlich jederzeit auf den jeweils aktuellen Kurs anpassen. Ich habe für dieses Beispiel den Kurs von 1,1968 vom 14.06.2004 genommen.

Als Ausgabe erhalten wir die nachstehende Tabelle. Sie hat zwar alle gewünschten Inhalte und ist im Rahmen der Anforderungen und Möglichkeiten formatiert - aber mal ehrlich: Möchten Sie die Tabelle in dieser Form ausdrucken, um sie in Ihre Brieftasche zu stecken?

Da man heutzutage nur noch Ausgaben mehr oder weniger perfekter Textverarbeitungen auf Papier sieht, wirkt diese Form ungewohnt und geradezu hölzern. Wie stellen wir aber die Verbindung zwischen unserem Programm und einer Textverarbeitung her? Auch für dieses Problem bietet uns Linux eine Lösung: Wir benutzen einfach LATEX, um unsere Ausgabe zu formatieren. Es wird bei jeder Distribution mitgeliefert und ist so leistungsstark, dass wir uns nicht mit den Ausgabeformaten abmühen müssen, sondern diese Aufgabe einer Anwendung überlassen können, die sie sehr viel besser lösen kann. Das Prinzip ist ganz einfach: Wir erzeugen mit unserem Programm eine Eingabedatei für LATEX, starten es dann und wandeln, wenn alles bis hierher gut gegangen ist, die DVI-Datei (ein geräteunabhängiges Textausgabeformat, das aus dem LATEX-Code als Zwischenformat erzeugt wird) in eine PostScript-Datei um. Der folgende Code realisiert dieses Vorhaben.

In diesem Programm dürften gleich einige Dinge für Sie neu sein. Betrachten wir es also etwas genauer.

String-Streams

Bisher waren unsere Streams solche Ströme, die auf dem Bildschirm oder in Dateien etwas ausgegeben haben oder aus ähnlichen Quellen etwas eingelesen haben. Die Streams waren also entweder einer Datei zugeordnet oder dem Terminal beziehungsweise der Tastatur. Sie können einen Stream jedoch auch einem String zuordnen, also einer Klasse für Zeichenketten. Auch wenn wir uns mit Strings aus der Standardbibliothek erst ab Seite 508 beschäftigen werden, möchte ich Ihnen an dieser Stelle schon einmal zeigen, wie Sie mit den Formatierungsmöglichkeiten der Streams in Strings schreiben können. (Das Lesen erfolgt ganz analog.) Einen solchen Stream für Strings bezeichnet man als String-Stream. Um diesen zu verwenden, müssen Sie die Datei sstream in Ihren Code einbinden.

Wie Sie etwa in den Zeilen 14 und 15 sehen, gehen Sie mit einem String-Stream genauso um wie mit einem anderen Ausgabestream (vergleiche Seite 316). Wenn Sie den Inhalt des String-Streams an anderer Stelle verwenden wollen, etwa als Dateiname wie in Zeile 17 oder als Aufrufargument wie in Zeile 43, müssen Sie den darin enthaltenen String extrahieren, also das Objekt vom Typ string. Ein Ausgabeoperator wie in Zeile 42 kann damit noch etwas anfangen; der Konstruktor des ofstream in Zeile 17 bereits nicht mehr. Hier zeigt sich wieder einmal deutlich der Bruch zwischen dem Anspruch von C++, eine vollkommen objektorientierte Sprache zu sein, und der Wirklichkeit, die durch viele Relikte aus der C-Vergangenheit geprägt ist. Der Konstruktor erwartet nämlich kein string-Objekt, sondern eine Zeichenkette im C-Stil, die wir im nächsten Abschnitt besprechen werden. Daher genügt es nicht, nur aus dem String-Stream einen String zu machen, es muss auch noch dieser in eine C-Zeichenkette umgewandelt werden. Das erklärt die Verschachtelung im Ausdruck

Eindeutigkeit der Ausgabe über die Prozess-ID

Da Linux ein Multitasking/Multiuser-Betriebssystem ist, sollte sich eigentlich jede Anwendung mit dem Gedanken vertraut machen, dass der oder die Benutzer sie auch mehrfach gleichzeitig ablaufen lassen können. Das bedeutet insbesondere für die Ausgabe in Dateien, dass bei einem festen Namen die verschiedenen Prozesse im schlimmsten Fall zugleich darauf zugreifen könnten und so ein Kauderwelsch entstehen ließen. Bei einfachen Tools macht man sich meist nicht die Mühe, diesen Fall zu berücksichtigen, sondern vertraut darauf, dass die Anwendung ohnehin stets in getrennten Verzeichnissen ausgeführt wird.

Wie aber könnte man das Problem doch in den Griff bekommen? Haben Sie schon eine Idee? Der Standardweg ist, den Dateinamen so zu ergänzen, dass er eindeutig wird. Und zur Feststellung der Eindeutigkeit eignet sich die Identifikationsnummer (ID) des Prozesses besonders gut. Schließlich kann ja das Betriebssystem anhand dieser Nummer die einzelnen Programme auch auseinander halten. Da liegt es nahe, diesen Wert für eine ähnliche Aufgabe ebenfalls einzusetzen. Wenn Sie etwa das Kommando

eingeben, erhalten Sie eine lange Liste aller gerade laufenden Prozesse. In der zweiten Spalte finden Sie die besagte Prozess-ID.

In diesem Zusammenhang stellt sich natürlich die Frage: Was ist ein Prozess? Auch wenn Sie keine systemnahe Programmierung machen wollen, sollten Sie eine ungefähre Vorstellung davon haben. Auf einem Linux-Rechner können jederzeit mehrere unabhängige Programme von verschiedenen Benutzern laufen; auch das Betriebssystem startet und unterhält mehrere solcher Programme, um die Benutzer und die Systemressourcen zu verwalten. Ein Prozess ist eines dieser Programme. Er besteht damit aus Programmcode, einigen Daten im Speicher, eventuell offenen Dateien oder anderen Ein-/Ausgabekanälen und manchmal auch aus Umgebungsvariablen. Er läuft in einem eigenen Adressraum, kann also nicht auf den Speicherbereich zugreifen, den andere Programme verwenden. Es ist allerdings möglich, dass Programmcode in Form von dynamischen Bibliotheken in mehreren Prozessen gleichzeitig verwendet wird (siehe auch Seite 50).

Zur Verwaltung aller Prozesse legt Unix eine Prozesstabelle an. Dort sind alle notwendigen Informationen über die gerade laufenden Prozesse hinterlegt. Um die Prozesse eindeutig unterscheiden zu können, vergibt Linux bei deren Start eine Prozessnummer. Weitere Daten über einen Prozess sind Name und Pfad des Programms, zugeordneter Benutzer (bei Systemprozessen root), CPU- und Speicherverbrauch, Start- und Laufzeit, Terminal und Status. Das ps-Kommando listet Ihnen alle Prozesse zu den angegebenen Kriterien auf (Näheres etwa unter man ps). Im Gegensatz dazu bietet Ihnen das top-Kommando eine Liste der Prozesse, die am meisten Rechenzeit verbrauchen. Diese Liste ist zudem nach dieser Eigenschaft absteigend sortiert und wird fortlaufend in bestimmten Intervallen aktualisiert. Mit dem angegebenen Prozentwert ist dabei gemeint, wie viele Arbeitsschritte (Takte) der CPU für diesen Prozess benutzt werden. Denn Multitasking bedeutet auf Rechnern mit einer CPU auch unter Unix lediglich, dass immer nur ein Prozess gleichzeitig die CPU verwendet, aber sehr oft zwischen den verschiedenen Prozessen umgeschaltet wird, so dass der Eindruck der Gleichzeitigkeit entsteht.

Tiefer kann ich im Rahmen dieses Buches leider nicht auf dieses Thema eingehen. Wenn Sie mehr wissen wollen, können Sie beispielsweise den Klassiker [HETZE et al. 1997] zu Rate ziehen.

Nun zurück zu unserem Beispiel: In einem C++-Programm können Sie die ID des Prozesses, in dem das Programm gerade läuft, über die Funktion getpid() erfahren. Damit der Compiler diese kennt, müssen Sie die Unix-System-Header-Datei unistd.h einbinden.

Wir verwenden sie beispielsweise in Zeile 15, wo sie Bestandteil des Namens der Ausgabedatei wird. Ist die ID etwa 837, so erhalten wir hier den Namen euro.837.tex. Auf diese Weise erzeugt so ziemlich jeder Lauf der Programms eine eigene Ausgabedatei - auf alle Fälle aber jeder gleichzeitige Lauf.

Aufruf anderer Programme

Wenn wir LATEX verwenden wollen, müssen wir uns klar machen, dass es sich dabei um ein separates Programm handelt. Solche rufen wir normalerweise aus einer Shell auf. Natürlich ist es aber auch möglich, aus einer Anwendung heraus einen anderen Prozess zu starten.

Dazu dient die Systemfunktion system(), die als Argument einen String mit genau den Angaben erwartet, die Sie auch in der Shell eingeben würden. Ihr Rückgabewert entspricht im Allgemeinen dem Rückgabewert der main()-Funktion des anderen Programms; nur wenn keine Shell gestartet werden kann, in der der Befehl laufen soll, wird 127 zurückgegeben und bei allen anderen Fehlern -1. Der Aufruf über system() ist dabei synchron, das heißt, die Funktion wartet so lange, bis das aufgerufene Programm beendet ist. Eventuelle Bildschirmausgaben dieses Programms erscheinen in derselben Shell, in dem Sie auch den übergeordneten Prozess gestartet haben.

In unserem Beispiel stellen wir in Zeile 42 das Kommando aus Programmname und Argument (hier: Dateiname) zusammen und rufen in Zeile 43 system(). Wenn diese Funktion 0 zurückgibt, die Abarbeitung also fehlerfrei war, können wir in Zeile 47 mit dvips (wird in Zeile 45 zusammengestellt) das nächste Tool aufrufen. Auf diese Weise haben wir nicht nur aus der Ausgabe unseres Programms eine LATEX-Quelldatei erzeugt, sondern diese auch gleich selbst in eine PostScript-Datei umgewandelt.

Fazit

Auch dieses Beispiel enthielt einige Zusatzinformationen über die Anwendung der Streams hinaus. Sie haben gelernt,

• wie man stringstream-Objekte zum Aufbau von Strings im Speicher einsetzt,
• wie man mit der Funktion getpid() die ID des Prozesses bestimmt,
• wie man diese ID verwendet, um Dateinamen eindeutig zu machen, und
• wie man andere Prozesse mittels system() aus dem eigenen starten kann.

Sicher sind Ihnen jetzt schon einige Ideen gekommen, wie Sie diese Techniken selbst einsetzen können. Also lassen Sie sich nicht aufhalten und gehen Sie an die Arbeit.

3.2.6 Zusammenfassung

Vom gesamten Abschnitt sollten Sie Folgendes in Erinnerung behalten:

• Die Standardkanäle für die Ein- und Ausgabe sind in C++ definiert als cin für die Standardeingabe (Tastatur), cout für die Standardausgabe (Bildschirm) und cerr für die Standardfehlerausgabe (Bildschirm). Alle Standardkanäle können auch umgeleitet werden.
• Bei der Eingabe verwendet man den ¿¿-Operator. Es werden so lange Zeichen akzeptiert, bis der Benutzer die Eingabetaste drückt.
• Für die Ausgabe dient der ¡¡-Operator. Mehrere Ausgaben unterschiedlichen Typs können darüber miteinander verkettet werden. Es werden alle auszugebenden Zeichen hintereinander gefügt; der Ausdruck endl sorgt für einen Zeilenumbruch.
• Für die grundlegenden Operationen mit Dateien gibt es die Klassen ofstream (Ausgabe in eine Datei), ifstream (Eingabe aus einer Datei) und fstream (Ein- und Ausgabe). Um Zugriff auf eine Datei zu haben, muss man ein Objekt einer dieser Klassen anlegen. Dazu ist das Einbinden der Header-Dateien iostream und fstream notwendig.
• Zum Öffnen gibt man entweder den Namen der Datei im Konstruktor an oder man erzeugt zunächst ein Objekt (mit Standardkonstruktor) und ruft dann die Methode open() auf. Das Schließen erfolgt automatisch im Destruktor, kann aber auch mit close() erreicht werden.
• Zur Abfrage des aktuellen Status eines Datei-Streams kann man das Objekt direkt verwenden oder die Methoden fail() beziehungsweise eof() aufrufen.
• Um in einer Datei an eine bestimmte Position zu springen, verwendet man die Methode seekp() für einen ostream und seekg für einen istream. Um eine Position zu bestimmen, stehen die Methoden tellp() beziehungsweise tellg() zur Verfügung.
• Die Methode width() oder der Manipulator setw() bestimmen die Breite der unmittelbar folgenden Ausgabe. Die Anzahl der Ziffern von Gleitkommazahlen wird mit der Methode precision() oder dem Manipulator setprecision() gesteuert. Eine Festlegung ist bis zum nächsten Aufruf von precision() gültig. Weitere Ausgabeflags können über die Methode setf() gesetzt werden.

3.2.7 Übungsaufgaben

1. Beantworten Sie folgende Fragen:
   • Was ist der Unterschied zwischen Standardausgabe und Standardfehlerausgabe? Wie macht sich dieser bemerkbar?
   • Muss man einen Stream vom Typ ofstream oder ifstream immer mit einem expliziten Aufruf von close() schließen?
   • Wie kann man den Dateizeiger in die Mitte der Datei setzen?
   • Welche Aufgabe hat ein Objekt vom Typ ostringstream?

2. Schreiben Sie ein Programm, das HTML-Code (der Einfachheit halber alles, was sich zwischen einem Paar spitzer Klammern befindet) aus einer Datei entfernt. Die Filterung selbst soll in einer eigenen Klasse erfolgen. In der main()-Methode sollen zwei Kommandozeilenargumente, nämlich die Namen von Quelldatei und Zieldatei, verarbeitet und der Filtervorgang damit aufgerufen werden.
3. Entwerfen Sie analog zur Klasse Datum auch eine Klasse Uhrzeit. Diese soll folgende Funktionsmerkmale umfassen:
   1. Sie soll Attributsvariablen für Stunde, Minute und Sekunde haben.
   2. Die Klasse soll beim Standardkonstruktor mit der aktuellen Uhrzeit initialisiert werden.
   3. Es soll aber auch ein Konstruktor mit Argumenten möglich sein, der eine bestimmte Zeit vorgibt.
   4. Außerdem soll es einen Konstruktor geben, der aus einer long-Zahl, welche die Sekunden seit 0:00 Uhr angibt, die Uhrzeit bestimmt.
   5. Für Stunden, Minuten und Sekunden sollen Zugriffsmethoden zum Lesen und Schreiben vorhanden sein.
   6. Die Klasse soll eine Methode
      long Uhrzeit::diff (Uhrzeit& _andere);

      enthalten, welche die Differenz zwischen zwei Zeitpunkten in Sekunden berechnet.

4. Implementieren Sie Ihre Version des Linux-Werkzeuges wc. Schreiben Sie also ein Programm, das den Namen einer Textdatei über die Kommandozeile aufnimmt und für dieses Datei die Anzahl der Zeichen, Wörter und Zeilen ausgibt.
5. Schreiben Sie ein Programm, das den Benutzer einen Dateinamen und eine Zahl eingeben lässt. Es soll dann diese Datei in mehrere Dateien der angegebenen Größe aufspalten. Die Zahl soll dabei die Größe in Kilobytes angeben. Beispiel: Es wird "myfile.txt" und "8" eingegeben. Ihr Programm stellt fest, dass die Ausgangsdatei myfile.txt genau 36800 Bytes groß ist. Dann soll das Programm fünf Dateien myfile.txt.1 bis myfile.txt.5 erzeugen. Die ersten vier sollen dabei 8192 Bytes, die letzte 4032 Bytes umfassen.

   Hinweis: Bestimmen Sie die Größe der Quelldatei durch Positionierung des Dateizeigers auf das Ende.

6. Schreiben Sie ein Programm, das die Werte der Sinusfunktionen an den Vielfachen von /8 zwischen 0 und 2 formatiert ausgibt.
7. In den Übungen zu Abschnitt 3.1.5 (ab Seite 313) haben Sie die Caesar-Verschlüsselung kennen gelernt. Schreiben Sie ein Programm, das als Kommandozeilenargumente den Namen einer Textdatei sowie eine Zahl (den Abstand) akzeptiert. Es soll sodann die Datei mit diesem Abstand chiffrieren und das Ergebnis in einer anderen Datei speichern. Verwenden Sie daher Ihre Klasse Caesar aus Abschnitt 3.1.5. (Hinweis: Für die Umwandlung des Kommandozeilenarguments in eine Zahl können Sie die Funktion atoi() einsetzen. Dafür müssen Sie die Header-Datei cstdlib einbinden.)

3.3 Felder, Zeiger und dynamische
Speicherverwaltung

Bisher haben wir alle Variablen und Objekte nur eindimensional verwendet. Von jedem Objekt hatten wir immer nur ein Exemplar - und wenn es mal zwei waren, hatten diese unterschiedliche Namen. Dieses Defizit ist aber auf Dauer nicht tragbar. In diesem Abschnitt wollen wir uns endlich mit der Frage beschäftigen, wie man in C++ Felder (Listen oder Vektoren) von Variablen und Objekten aufbaut und somit fast beliebig viel Speicher während der Laufzeit eines Programms nutzbar machen kann.

3.3.1 Felder (Arrays)

Ein Feld (engl. array) ist nichts anderes als eine durchnummerierte Menge von Variablen gleichen Typs. Sie können von jedem elementaren und von jedem selbst definierten Datentyp Felder bilden. Dazu geben Sie bei der Deklaration außer Typ und Namen lediglich die Anzahl der Elemente an. Für ein Feld von Ganzzahlen mit 10 Elementen etwa schreiben Sie:

Diese Anweisung bedeutet für den Compiler, nicht nur für eine int-Variable Speicher zu reservieren, sondern für 10, also insgesamt 40 Bytes - auf einer Intel-32-Bit-Architektur. (Sie können den Speicherverbrauch eines Datentyps oder einer Variablen übrigens auch selbst überprüfen, nämlich mit der Funktion sizeof(). In unserem Beispiel liefert sizeof(int) den Wert 4 und sizeof(a) die Zahl 40.)

Nun können Sie auf das Feld zugreifen, das heißt seine Elemente mit Werten belegen und später wieder auslesen. Dazu gibt es den Indexoperator, der aus einem Paar eckiger Klammern [] besteht. In diesen geben Sie den Index des Elements an, das Sie bearbeiten möchten, zum Beispiel:

Damit sind wir schon bei der größten Fehlerquelle im Zusammenhang mit Arrays:

Was geschieht eigentlich, wenn Sie über die Größe Ihres Feldes hinausschreiben? Das Programm legt zumeist seine Variablen hintereinander an, nach Möglichkeit ohne Lücken. Wenn Sie also beispielsweise nur zehn Elemente reserviert haben und auf ein elftes zugreifen, ändern Sie damit den Wert einer anderen Variablen. Im schlimmsten Fall stehen dort aber Variablen eines anderen Prozesses oder gar Programmanweisungen. Das heißt, Sie ändern den Speicherinhalt an einer kaum vorhersagbaren Stelle. Entsprechend unvorhersehbar sind die Folgen. Meist führen solche Fehler leider nicht sofort zu Abstürzen, sondern erst einige Zeit später, an einer Stelle mit völlig korrektem Code, der eben auf den zerstörten Speicherbereich zugreifen will. Ihr Programm endet dann abrupt mit der Meldung: Segmentation fault. Bei einem solchen Fehler sollten Sie daher immer zuerst an unerlaubte Speicherzugriffe denken.

Ich habe Sie schon bei einfachen Variablen gewarnt, dass diese nach einer Deklaration völlig undefinierte Werte haben können und Sie daher stets so früh wie möglich für eine Initialisierung sorgen sollten. Bei Feldern vervielfacht sich Ihr Problem lediglich. Aber auch hier können Sie gleichzeitig mit der Deklaration das Feld initialisieren. Dabei geben Sie die gewünschten Inhalte als Liste in geschweiften Klammern {} an, getrennt durch Kommas.

Wenn Sie jetzt besonders ökonomisch denken, werden Sie sagen: "Damit gebe ich doch die Anzahl der Elemente zweimal an, einmal als explizite Größenangabe und einmal implizit durch die Zahl der Initialisierungswerte!" In der Tat müssen Sie nämlich für alle deklarierten Elemente auch einen Wert in der Initialisierungsliste eintragen; also könnte man doch diese Anzahl gleich als Größenangabe verwenden. Der Compiler unterstützt solche Überlegungen sehr wohl:

Ich möchte Ihnen aber empfehlen, derartige Konstrukte nur sehr selten einzusetzen. Ich finde es wesentlich übersichtlicher, wenn man gleich mit einem Blick auf die Deklaration sieht, wie viele Elemente ein Feld hat, das heißt, bis zu welchem Index man zugreifen darf - und nicht erst nachzählen muss. Bei drei Einträgen ist das sicher harmlos, bei circa acht und mehr aber eine zusätzliche Fallgrube. Da es davon ohnehin genug gibt, müssen wir nicht noch selbst welche graben.

Felder können auch mehrere Dimensionen haben. Dazu fügen Sie einfach weitere Größenangaben in eckigen Klammern an die Deklaration an. Eine 3 × 4-Matrix etwa können Sie deklarieren als:

Auch beim Zugriff auf die Elemente gilt: pro Dimension ein Index. Wenn Sie diese Matrix beispielsweise mit null initialisieren wollen, brauchen Sie dazu folgende Schleifen:

Felder nehmen in C++ unter den Top 10 der Quellen der verheerendsten Fehler einen der vordersten Plätze ein. Sie sind ein Relikt aus C, wo man sehr viel Wert auf eine möglichst systemnahe Programmierung legte. In C++ besteht aber eigentlich keine Notwendigkeit dafür, Felder zu verwenden, da die C++-Standardbibliothek alle Arten von Containern, also Listen, Vektoren, Stapel und so weiter, in effizienter und robuster Form bereitstellt. Ich möchte Ihnen daher empfehlen, in Ihren Programmen nach Möglichkeit auf Felder zu verzichten und ausschließlich die Klassen der Standardbibliothek zu verwenden. Mehr dazu erfahren Sie ab Seite 506.

Ein weiterer Nachteil von Feldern ist, dass Sie bereits im Code die genaue Zahl der Elemente angeben müssen. Der Wert muss dabei auf alle Fälle eine Konstante sein, die während des Kompilierens bestimmbar ist. Es ist also nicht möglich, in dieser Form ein Feld zu definieren, dessen Größe Sie erst während der Laufzeit des Programms ermitteln, zum Beispiel:

Wie Sie sicher bald merken werden, ist das eine erhebliche Einschränkung. Will man in einem Programm für alle Eventualitäten gewappnet sein, muss man auch mit unerwartet großen Datenfeldern umgehen können. Auch in diesem Punkt bieten Ihnen die Container der C++-Standardbibliothek nur Vorteile.

Hintergrund

Ich kann Sie aber nur warnen, eine solche Konstruktion zu nutzen. Denn einer der bedeutenden Vorteile von C und C++ ist die Portabilität, die nur durch die Standardisierung erreicht wurde. Wenn Sie auf Compiler-Erweiterungen vertrauen, bedeutet das auch, dass Ihr Code von kaum einem anderen Compiler noch übersetzbar ist. Außerdem kann diese Erweiterung in künftigen Versionen eventuell wegfallen. Betrachten Sie also lieber stets die Feldgröße als eine feste Konstante, dann bleiben Sie auf der sicheren Seite.

3.3.2 Zeichenketten

Wenn wir bislang Zeichenketten für Namen oder Beschriftungen brauchten, haben wir immer Objekte der Klasse string der C++-Standardbibliothek verwendet (Genaueres ab Seite 508). Das ist eine robuste und sichere Vorgehensweise; allerdings gehört diese Klasse erst seit dem ANSI/ISO-Standard von 1998 verbindlich zu C++. Der traditionelle Weg, Zeichenketten zu speichern, ist der von C übernommene: in Form von Feldern des Typs char. Eigentlich bräuchte man sich heute damit gar nicht mehr zu beschäftigen, wenn es nicht viele Systemfunktionen gäbe, die als Argumente oder Rückgabewerte gerade ein solches Zeichen-Array haben. Und da diese Funktionen sämtlich in C geschrieben sind, wird das auch noch länger so bleiben.

Die einfachste Möglichkeit, ein char-Feld zu definieren, ist diejenige mit impliziter Größenangabe. Da selten auf einzelne Elemente zuzugreifen ist, wird dieser Weg relativ häufig eingesetzt:

Letztlich ist eine Zeichenkette nur ein Stück Speicher, das dann als Zeichen interpretiert wird. Der Datentyp char entspricht nämlich genau einem Byte. Damit das Programm beim Interpretieren weiß, wo der String aufhört und andere Variablen anfangen, haben die Erfinder von C die 0 definiert (so genannte Nullterminierung). Das bedeutet, dass

• jede Zeichenkette als letztes Zeichen den Wert 0 (nicht die Ziffer "0"!) enthält, so dass der Speicherbedarf um eins größer ist als die Anzahl der Zeichen, und
• beim Fehlen der 0 alle Speicherstellen bis zur nächsten, die den Wert 0 aufweist, als Teil des Strings interpretiert werden.

Letzterer Fall kommt zwar nicht allzu häufig vor, kann aber dann ziemlich unerwartete Ausgaben hervorrufen. Auf der anderen Seite heißt das aber auch, dass Sie den String abkürzen können, wenn Sie eines der Elemente auf 0 setzen. So wird aus obigem String txt durch

nur noch "Unse". Folglich ist hier die explizite Größenangabe bei der Deklaration sogar gefährlich, weil Sie dabei leicht die abschließende 0 vergessen.

Bei der Eingabe können Sie Zeichen-Arrays wie andere einfache Datentypen behandeln. Dabei ist allerdings die begrenzte Länge zu beachten:

Gibt der Benutzer hier mehr als 19 Zeichen ein, kommt es zu einem der gefährlichen Speicherfehler, die ich oben beschrieben habe. Besser ist es, die Methode getline zu verwenden, bei der Sie die Maximalgröße der Eingabe zusätzlich übergeben. Ist die Eingabe länger, wird sie abgeschnitten.

(Dieser Code lässt sich im Gegensatz zu dem vom Ende des letzten Abschnitts übersetzen, da GROESSE als Konstante deklariert ist und sich daher zur Laufzeit nicht ändern kann.)

Wenn Sie auf diese Weise ein Zeichenfeld definiert haben, dürfen Sie ihm nicht als Ganzes ein anderes zuweisen.

Für weitere Bearbeitungsmöglichkeiten von Zeichenfeldern brauchen wir den Begriff des Zeigers, den ich im folgenden Abschnitt einführen werde. Damit können Sie dann Funktionen verwenden, um Zeichenfelder zu kopieren, ihre Länge zu messen, Zeichen darin zu suchen und so weiter. Außerdem werden Sie eine Methode kennen lernen, um Zeichenfelder mit variabler Größe anzulegen.

3.3.3 Zeiger

In den klassischen C-orientierten Lehrbüchern für C++ taucht der Begriff des Zeigers meist so früh auf, dass er mehr für Verwirrung als für Klarheit sorgt. Dass wir uns durch viele wesentliche Konzepte und Sprachelemente von C++ bis hierher durcharbeiten konnten, ohne Zeiger zu benötigen, macht jedoch deutlich, dass C++ mit einer sehr sparsamen Verwendung von Zeigern auskommt. Diese Vorgehensweise möchte ich Ihnen auch ganz allgemein empfehlen - noch bevor Sie überhaupt wissen, von was da eigentlich die Rede ist.

Was ist ein Zeiger?

Dass wir bislang überhaupt keine Zeiger benötigten, stimmt auch nicht so ganz. Bei einigen Aufrufen von Systemfunktionen habe ich mich nur etwas vor dem Begriff gedrückt und von "Speicherstellen" oder Ähnlichem gesprochen, Sie aber gleichzeitig mit der Syntax etwas im Unklaren gelassen. Wobei die Vorstellung einer "Speicherstelle" dem eigentlichen Begriff aber schon recht nahe kommt.

Definieren wir also:

Sie erfahren über den Zeiger also, an welcher Stelle im Hauptspeicher sich die Variable befindet. Damit ist der Manipulation des Speichers natürlich Tür und Tor geöffnet; entsprechend groß sind die Risiken. Obgleich ein Zeiger immer einen bestimmten Typ haben muss, ist es nicht absolut zwingend, dass der Speicherbereich, auf den er zeigt, ein existierendes Objekt ist. Über den Zeiger kann der Bereich erst als solches interpretiert werden.

Syntax bei Zeigern

Man deklariert einen Zeiger auf ein Objekt vom Typ T, indem man den *-Operator hinter den Typ setzt, etwa

Damit stellt der Zeiger zwar einen eigenen Typ dar, der aber von dem des referenzierten Objekts abhängt. Beachten Sie, dass man auch Zeiger auf einen Zeiger (und so weiter!) definieren kann:

Es ist übrigens auch erlaubt, den Stern nicht an den Typ zu hängen, sondern unmittelbar vor die Zeigervariable zu setzen (allerdings auf keinen Fall dahinter!):

Da der Compiler beide Schreibweisen unterstützt, ist es letztlich Gewohnheits- oder Geschmackssache. Ich finde es besser, den Stern direkt an den Typ zu hängen, weil damit die Bildung des Zeigertyps deutlicher wird.

Wenn Sie mehrere Zeiger gleichzeitig deklarieren, gilt der Stern indessen nur für den ersten - oder muss ausdrücklich vor jeden gesetzt werden:

Aufgrund dieser Problematik gewinnt die Schreibweise mit dem Stern an der Variablen wieder etwas mehr Sinn.

Die Speicheradresse eines bestehenden Objekts können Sie sich über den Adressoperator & verschaffen, beispielsweise:

Hat man schon einen Zeiger, will man natürlich auch den Inhalt der Speicherstelle, auf die er zeigt, ermitteln und verändern. Dazu wird abermals der Stern verwendet, diesmal als Dereferenzierungsoperator.

Einen solchen Zugriff nennt man auch Indirektion. In diesem Beispiel haben wir den Wert der Variablen n verändert, indem wir den Inhalt ihrer Speicherstelle modifizierten. In diesem Sinne ähneln Zeiger sehr Referenzen; der Unterschied ist, dass bei Referenzen der Compiler bereits für Bestimmung der Adresse und Indirektion sorgt.

Bei Zeigern auf Objekte müssen Sie beachten, dass der "."-Operator für den Zugriff auf einzelne Elemente Vorrang vor dem Dereferenzierungsoperator hat. Wenn Sie also ein Element verändern möchten, müssen Sie die Indirektion klammern.

Das ist nicht nur unpraktisch, sondern auch unübersichtlich und fehleranfällig. Daher sollten Sie zur Dereferenzierung von Objektelementen ausschließlich den Operator -¿ einsetzen. Äquivalent zu obiger Anweisung ist nämlich:

Zeiger und Arrays

Eine Feldvariable wird in C++ als ein Zeiger auf das erste Feldelement betrachtet (wobei sich der Compiler nur noch für die Initialisierung die Größe merkt). Damit können Sie ein Feld problemlos einem Zeiger zuweisen:

Entsprechend können Sie statt über den Indexoperator ein Feld auch wie einen Zeiger dereferenzieren - und umgekehrt. Dabei ist a[0] äquivalent zu *a, a[1] äquivalent zu *(a+1), a[2] äquivalent zu *(a+2) und so weiter. Da dies auch die Sichtweise des Compilers auf ein Array widerspiegelt, wird Ihnen nun vermutlich etwas klarer, warum eine Überprüfung auf Überschreitung der Feldgrenzen nicht stattfindet.

Nullzeiger

Zeiger sollten ebenso wie alle anderen Variablen unmittelbar bei oder nach der Deklaration initialisiert werden. Ein spezieller Zeigerwert, der für diesen Zweck genutzt werden kann, ist 0. Ein mit 0 belegter Zeiger zeigt definitiv auf "nichts".

Ebenso sollten Sie einen Zeiger, den Sie momentan nicht benötigen, weil er auf ein noch nicht oder nicht mehr existierendes Objekt verweist, mit 0 belegen.