vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbacknächstes Kapitel


Woche 1

Tag 2

Die Bestandteile eines C++- Programms

C++-Programme bestehen aus Objekten, Funktionen, Variablen und anderen Komponenten. Der größte Teil dieses Buches widmet sich in aller Ausführlichkeit der Beschreibung dieser Teile. Um jedoch einen Eindruck davon zu erhalten, wie die Bausteine eines Programms zusammenarbeiten, stelle ich Ihnen vorab ein vollständiges ausführbares Programm vor. Heute lernen Sie,

Ein einfaches Programm

Das einfache Programm HELLO.CPP aus Kapitel 1, »Erste Schritte«, weist verschiedene interessante Teile auf. Der vorliegende Abschnitt untersucht dieses Programm eingehender. Listing 2.1 zeigt noch einmal die Originalversion des Programms HELLO.CPP.

Listing 2.1: HELLO.CPP demonstriert die Bestandteile eines C++-Programms

1: #include <iostream.h>
2:
3: int main()
4: {
5: cout << "Hello World!\n";
6: return 0;
7: }

Hello World!

Zeile 1 bindet die Datei IOSTREAM.H in die Datei HELLO.CPP ein.

Dabei wird wie folgt vorgegangen: Das erste Zeichen, das #-Symbol, ist ein Signal an den Präprozessor. Der Präprozessor ist Ihrem Compiler vorgeschaltet und wird jedes Mal gestartet, wenn Sie den Compiler aufrufen. Der Präprozessor geht Ihren Quellcode durch und sucht nach Zeilen, die mit dem Nummernzeichen (#) beginnen. Diese Zeilen werden bearbeitet, bevor der Compiler gestartet wird. Der Präprozessor wird noch im einzelnen in Kapitel 21, »Was kommt als nächstes«, besprochen.

Die Präprozessor-Anweisung include (englisch: einbinden) hat folgende Bedeutung: »Es folgt ein Dateiname. Suche die Datei und lese sie genau an diese Stelle ein.« Die spitzen Klammern um den Dateinamen weisen den Präprozessor an, »an allen üblichen Plätzen nach dieser Datei zu suchen«. Wenn Ihr Compiler korrekt eingerichtet ist, bewirken die spitzen Klammern, daß der Präprozessor nach der Datei IOSTREAM.H in dem Verzeichnis sucht, in dem die .H-Dateien für Ihren Compiler stehen. Die Datei IOSTREAM.H (Input-Output-Stream) ist für cout erforderlich und unterstützt das Schreiben auf dem Bildschirm. Zeile 1 sorgt dafür, daß die Datei IOSTREAM.H in das Programm kopiert wird, so als hätten Sie den entsprechenden Quelltext selbst eingetippt. Jedes Mal, wenn Sie den Compiler aufrufen, wird zuerst der Präprozessor ausgeführt. Dieser Präprozessor übersetzt jede Zeile, die mit einem Nummernzeichen (#) beginnt, in einen speziellen Befehl und bereitet damit Ihren Quellcode für den Compiler auf.

In Zeile 3 beginnt das eigentliche Programm mit einer Funktion namens main(). Jedes C++-Programm verfügt über eine main()-Funktion. Im allgemeinen ist eine Funktion ein Codeblock, der eine oder mehrere Aktionen ausführt. Funktionen werden von anderen Funktionen aufgerufen, wobei die Funktion main() eine Sonderstellung einnimmt. Bei Start des Programms erfolgt der Aufruf von main() automatisch.

Wie alle anderen Funktionen muß auch main() festlegen, welche Art von Rückgabewert sie liefert. Der Rückgabewert von main() in HELLO.CPP ist vom Typ int, das heißt, diese Funktion wird beim Beenden einen Integer an das Betriebssystem übergeben. In diesem Fall ist es der Integerwert 0, wie in Zeile 6 zu sehen. Einen Rückgabewert an das Betriebssystem zu deklarieren, ist eigentlich unwichtig und wird selten benötigt. Der C++-Standard jedoch erfordert, daß main() wie gezeigt deklariert wird.

Bei einigen Compilern können Sie den Rückgabewert von main() als void deklarieren. Das entspricht jedoch nicht mehr dem gültigen C++-Standard, und Sie sollten es vermeiden, in schlechte Angewohnheiten zu verfallen. Besser ist es, main() einen Integer zurückliefern zu lassen und in der letzten Zeile von main() eine 0 zurückzugeben.

Einige Betriebssysteme ermöglichen es Ihnen, den Rückgabewert eines Programms zu prüfen. Der Konvention nach sollte der Wert 0 sein, um anzuzeigen, daß das Programm ordnungsgemäß beendet wurde.

Funktionen beginnen mit einer öffnenden geschweiften Klammer ({) und enden mit einer schließenden geschweiften Klammer (}). Die geschweiften Klammern für die Funktion main() stehen in den Zeilen 4 und 7. Alles zwischen der öffnenden und der schließenden Klammer ist Teil der Funktion.

Die »Knochenarbeit« dieses Programms leistet Zeile 5. Das Objekt cout gibt eine Meldung auf dem Bildschirm aus. Die Behandlung von Objekten im allgemeinen finden Sie in Kapitel 6, »Klassen«, und eine eingehende Beschreibung von cout und seinem verwandten Objekt cin in Kapitel 16, »Streams«. Diese beiden Objekte realisieren in C++ die Ausgabe auf den Bildschirm und die Eingabe über die Tastatur.

Im Anschluß an das Objekt cout steht der Umleitungsoperator (<<). Alles was auf den Umleitungsoperator folgt, erscheint auf dem Bildschirm. Möchten Sie eine Zeichenfolge ausgeben, ist diese in Anführungszeichen (") wie in Zeile 5 zu setzen.

Eine Textzeichenfolge ist eine Folge von druckbaren Zeichen.

Die beiden letzten Zeichen, \n, weisen cout an, eine neue Zeile nach dem Text Hello World! auszugeben. Dieser spezielle Code wird noch in Kapitel 17, »Namensbereiche«, ausführlicher im Zusammenhang mit cout erklärt.

Die Funktion main() endet in Zeile 7 mit der schließenden geschweiften Klammer.

Eine kurze Einführung in cout

In Kapitel 16 werde ich Ihnen ausführlich zeigen, wie Sie cout einsetzen, um Daten auf dem Bildschirm auszugeben. Bis dahin werden wir cout einfach verwenden, ohne seine Funktionsweise vollständig zu verstehen. Um einen Wert auf dem Bildschirm auszugeben, müssen Sie cout eingeben, gefolgt von dem Umleitungsoperator (<<), den man durch zweimaliges Betätigen der [<]-Taste erzeugt. Auch wenn es sich hier um zwei Zeichen handelt, werden sie von C++ als ein Symbol interpretiert. Im Anschluß an den Umleitungsoperator geben Sie Ihre auszugebenden Daten ein. Listing 2.2 soll Ihnen die Anwendung demonstrieren. Geben Sie das folgende Beispiel wortgetreu ein, nur daß Sie statt des Namens Jesse Liberty Ihren eigenen Namen eintippen (es sei denn, Ihr Name lautet ebenfalls Jesse Liberty).

Listing 2.2: Die Verwendung von cout

 1: // Listing 2.2 zeigt die Verwendung von cout
2: #include <iostream.h>
3: int main()
4: {
5: cout << "Hallo dort.\n";
6: cout << "Hier ist 5: " << 5 << "\n";
7: cout << "Der Manipulator endl beginnt eine neue Zeile.";
8: cout <<
9: endl;
10: cout << "Hier ist eine große Zahl:\t" << 70000 << endl;
11: cout << "Hier ist die Summe von 8 und 5:\t" << 8+5 << endl;
12: cout << "Hier ist ein Bruch:\t\t" << (float) 5/8 << endl;
13: cout << "Und eine riesengroße Zahl:\t";
14: cout << (double) 7000 * 7000 <<
15: endl;
16: cout << "Vergessen Sie nicht, Jesse Liberty durch Ihren Namen"
" zu ersetzen...\n";
17: cout << "Jesse Liberty ist ein C++-Programmierer!\n";
18: return 0;
19: }

Hallo dort.
Hier ist 5: 5
Der Manipulator endl beginnt eine neue Zeile.
Hier ist eine große Zahl: 70000
Hier ist die Summe von 8 und 5: 13
Hier ist ein Bruch: 0.625
Und eine riesengroße Zahl: 4.9e+07
Vergessen Sie nicht, Jesse Liberty durch Ihren Namen zu ersetzen...
Jesse Liberty ist ein C++-Programmierer!

Einige Compiler weisen einen Fehler auf und benötigen Klammern um die Addition, bevor sie an cout weitergeleitet wird. In diesem Falle würde Zeile 11 geändert in:

11:     cout << "Hier ist die Summe von 8 und 5:\t" << (8+5) << endl;

Zeile 2 bindet mit der Anweisung #include <iostream.h> die Datei IOSTREAM.H in Ihre Quellcode-Datei ein. Dies ist erforderlich, um cout und die verwandten Funktionen verwenden zu können.

Zeile 5 zeigt den einfachsten Einsatz von cout. Es wird einfach ein Zeichenstring ausgegeben. Das Symbol /n ist ein besonderes Formatierungszeichen. Es teilt cout mit, das Zeichen für eine neue Zeile auf dem Bildschirm auszugeben.

In Zeile 6 werden cout drei Werte übergeben, wobei die Werte voneinander durch einen Umleitungsoperator getrennt werden. Der erste Wert ist der String »Hier ist 5: « Beachten Sie das Leerzeichen nach dem Doppelpunkt. Dieser Raum ist Teil des Strings. Anschließend wird dem Umleitungsoperator der Wert 5 und das Zeichen für NeueZeile (immer in doppelten oder einfachen Anführungszeichen) übergeben. Damit wird insgesamt folgende Zeile

Hier ist 5: 5

auf dem Bildschirm ausgegeben. Da hinter dem ersten String kein NeueZeile-Zeichen kommt, wird der nächste Wert direkt dahinter ausgegeben. Dies nennt man auch »die zwei Werte verketten« (Konkatenation).

Zeile 7 gibt eine Meldung aus und verwendet dann den Manipulator endl. Sinn und Zweck von endl ist es, eine neue Zeile auf dem Bildschirm auszugeben. (Andere Anwendungsbereiche für endl stelle ich Ihnen in Kapitel 16 vor.)

endl steht für end line (Ende der Zeile) und nicht für end-eins (end1). Ausgesprochen wird es »end-ell«.

Zeile 10 führt ein neues Formatierungszeichen, das \t, ein. Damit wird ein Tabulator eingefügt, mit dem die Ausgaben der Zeilen 10 bis 13 bündig ausgerichtet werden. Zeile 10 zeigt, daß nicht nur Integer, sondern auch Integer vom Typ long ausgegeben werden können. Zeile 11 zeigt, daß cout auch einfache Additionen verarbeiten kann. Der Wert 8+5 wird an cout weitergeleitet und dann als 13 ausgegeben.

In Zeile 12 wird cout der Wert 5/8 übergeben. Mit dem Begriff (float) teilen Sie cout mit, daß das Ergebnis als Dezimalzahl ausgewertet und ausgegeben werden soll. In Zeile 14 übernimmt cout den Wert 7000 * 7000. Der Begriff (double) teilt cout mit, daß Sie diese Ausgabe in wissenschaftlicher Notation wünschen. Diese Themen werden wir noch im Detail in Kapitel 3, »Variablen und Konstanten«, im Zusammenhang mit den Datentypen besprechen.

In Zeile 16 haben Sie meinen Namen durch Ihren Namen ersetzt. Die Ausgabe bestätigt Ihnen, daß Sie tatsächlich ein C++-Programmierer sind. Und das muß wohl so sein, wenn der Computer das sagt!

Kommentare

Wenn man ein Programm schreibt, ist alles sonnenklar und bedarf keiner weiteren Erläuterung. Kehrt man aber einen Monat später zu diesem Programm zurück, sieht die Welt schon anders aus. Die selbst verfaßten Zeilen geben nur noch Rätsel auf.

Um diese Unklarheiten von vornherein zu bekämpfen und anderen Personen das Verständnis des Codes zu erleichtern, schreibt man gewöhnlich Kommentare in das Programm. Dabei handelt es sich einfach um Text, den der Compiler ignoriert, der aber den Leser über die Wirkung des Programms an bestimmten Punkten informiert.

Typen von Kommentaren

In C++ unterscheidet man zwei Arten von Kommentaren. Der Kommentar mit doppelten Schrägstrichen im Stil von C++ weist den Compiler an, alles nach den Schrägstrichen bis zum Ende der Zeile zu ignorieren.

Der durch Schrägstrich und Sternchen (/*) eingeleitete Kommentar weist den Compiler an, alles zu ignorieren, bis die abschließende Kommentarmarkierung (*/) erscheint. Diese Markierungen sind Kommentare im Stil von C und wurden in C++ übernommen. Achten Sie darauf, daß jedes /* durch ein entsprechendes */ abzuschließen ist.

Wie Sie sich vielleicht denken können, kann man Kommentare, wie sie in C verwendet werden, auch in C++ einsetzen. Hingegen sind C++-Kommentare nicht Teil der offiziellen Spezifikation von C.

Viele C++-Programmierer verwenden vorrangig Kommentare im Stil von C++ und heben sich die C-artigen Kommentare für das Ausklammern von großen Programmblöcken auf. Man kann C++-Kommentare innerhalb eines durch C-Kommentare »auskommentierten« Blocks einbinden. Alles zwischen den C-Kommentarmarken, einschließlich der C++-Kommentare, wird dann ignoriert.

Die Verwendung von Kommentaren

In der ersten und zweiten Ausgabe dieses Buches habe ich geschrieben, daß das Gesamtprogramm zu Beginn einen Kommentar aufweisen sollte, um anzugeben, was das Programm macht. Auch jede Funktion sollte mit einem Kommentar versehen werden, der mitteilt, was die Funktion macht und welche Werte sie zurückliefert.

Inzwischen halte ich nicht mehr allzu viel davon. Vor allem Kommentare im Kopf sind nicht mehr gefragt, da so gut wie niemand daran denkt, die Kommentare zu aktualisieren, wenn der Quellcode aktualisiert wird. Und was Funktionen anbelangt, so sollte man Funktionsnamen wählen, die möglichst aussagekräftig sind und keine Mehrdeutigkeiten aufkommen lassen. Ein verwirrender und schwer zu durchschauender Code sollte neu entworfen und umgeschrieben werden, damit er möglichst selbsterklärend ist. Meistens sind Kommentare nur die Entschuldigung von faulen Programmierern für ihren undurchschaubaren Quellcode.

Damit möchte ich Ihnen nicht nahelegen, Kommentare niemals zu verwenden. Sie sollten nur nicht dazu genutzt werden, um einen unübersichtlichen Code verständlich zu machen. In so einem Fall sollten Sie lieber den Code überarbeiten. Kurz gesagt, schreiben Sie einen guten Code und nutzen Sie die Kommentare, um das Verständnis zu erhöhen.

Kommentare kosten nichts, der Compiler ignoriert sie, und sie haben keinen Einfluß auf die Leistung des Programms. Listing 2.2 verdeutlicht die Verwendung von Kommentaren.

Listing 2.3: Hello.cpp mit eingefügten Kommentaren

 1: #include <iostream.h>
2:
3:int main()
4: {
5: /* Das ist ein Kommentar, der
6: bis zum schließenden Kommentarzeichen aus
7: Sternchen und Schrägstrich geht */
8: cout << "Hello World!\n";
9: // Dieser Kommentar geht nur bis zum Zeilenende
10: cout << "Der Kommentar ist beendet!";
11:
12: // C++-Kommentare können allein in einer Zeile stehen
13: /* genau wie diese Kommentare */
14: return 0;
15: }

Hello World!
Der Kommentar ist beendet!

Die Kommentare in den Zeilen 5 bis 7 ignoriert der Compiler gänzlich. Das gleiche gilt für die Kommentare in den Zeilen 9, 12 und 13. Der Kommentar auf Zeile 9 geht nur bis zum Zeilenende, während die Kommentare in den Zeilen 5 und 13 ein schließendes Kommentarzeichen erfordern.

Ein letztes Wort zu guten Kommentaren

Kommentare, die beschreiben, was eh schon jeder sieht, sind nicht besonders sinnvoll. Sie können sogar kontraproduktiv sein, wenn sich der Code ändert und der Programmierer vergißt, den Kommentar mit zu ändern. Aber was für den einen offensichtlich ist, ist für andere undurchsichtig. Deshalb ist sorgfältiges Abwägen gefragt.

Zu guter Letzt möchte ich noch anmerken, daß Kommentare nicht mitteilen sollten, was Sie tun, sondern warum Sie es tun.

Funktionen

Die Funktion main() ist etwas ungewöhnlich. Normalerweise muß eine Funktion, um etwas leisten zu können, im Verlauf Ihres Programms aufgerufen werden. main() wird vom Betriebssystem aufgerufen.

Programme werden Zeile für Zeile ausgeführt, in der Reihenfolge, in der Sie den Quellcode aufgesetzt haben. Bei einem Funktionsaufruf verzweigt das Programm, um die Funktion auszuführen. Ist die Funktion beendet, springt die Programmausführung zurück zu der Zeile in der aufrufenden Funktion, die auf den Funktionsaufruf folgt.

Stellen Sie sich vor, daß Sie ein Bild von sich selbst zeichnen. Sie zeichnen den Kopf, die Augen, die Nase - und plötzlich bricht Ihr Bleistift ab. Sie »verzweigen« nun in die Funktion »Bleistift spitzen«. Das heißt, Sie hören mit dem Zeichnen auf, stehen auf, gehen zur Spitzmaschine, spitzen den Stift, kehren an Ihre Arbeit zurück und setzen sie dort fort, wo Sie aufgehört haben. Wenn ein Programm eine bestimmte Arbeit verrichtet haben möchte, kann es dafür eine Funktion aufrufen und nach Abarbeitung der Funktion genau an dem Punkt weitermachen, wo es aufgehört hat. Listing 2.4 verdeutlicht dieses Konzept.

Listing 2.4: Aufruf einer Funktion

 1:     #include <iostream.h>
2:
3: // Funktion DemonstrationFunction
4: // gibt eine Meldung aus
5: void DemonstrationFunction()
6: {
7: cout << "In DemonstrationFunction\n";
8: }
9:
10: // Funktion main - gibt eine Meldung aus, ruft
11: // dann DemonstrationFunction auf, gibt danach
12: // eine zweite Meldung aus.
13: int main()
14: {
15: cout << "In main\n" ;
16: DemonstrationFunction();
17: cout << "Zurueck in main\n";
18: return 0;
19: }

In main
In DemonstrationFunction
Zurueck in main

Die Zeilen 5 bis 8 enthalten die Definition der Funktion DemonstrationFunction(). Die Funktion gibt eine Meldung auf dem Bildschirm aus und kehrt dann zum Aufrufer zurück.

In Zeile 13 beginnt das eigentliche Programm. In Zeile 15 gibt die Funktion main() eine Meldung aus, daß sich das Programm soeben in der Funktion main() befindet. Nach der Ausgabe der Meldung ruft Zeile 16 die Funktion DemonstrationFunction() auf. Dieser Aufruf bewirkt die Ausführung der Befehle in DemonstrationFunction(). In diesem Fall besteht die gesamte Funktion aus dem Code in Zeile 7, der eine weitere Meldung ausgibt. Nach vollständiger Abarbeitung der Funktion DemonstrationFunction() in Zeile 8 kehrt die Programmausführung an die Stelle zurück, wo der Aufruf der Funktion erfolgte. Im Beispiel kehrt das Programm zu Zeile 17 zurück, und die Funktion main() gibt die abschließende Meldung aus.

Funktionen verwenden

Funktionen geben entweder einen Wert oder void (das heißt: nichts) zurück. Eine Funktion zur Addition von zwei ganzen Zahlen liefert sicherlich die Summe zurück, und man definiert diesen Rückgabewert vom Typ Integer. Eine Funktion, die lediglich eine Meldung ausgibt, hat nichts zurückzugeben und wird daher als void (zu deutsch: leer) deklariert.

Funktionen gliedern sich in Kopf und Rumpf. Der Kopf besteht wiederum aus dem Rückgabetyp, dem Funktionsnamen und den Parametern. Mit Parametern lassen sich Werte an eine Funktion übergeben. Soll eine Funktion zum Beispiel zwei Zahlen addieren, stellen die Zahlen die Parameter für die Funktion dar. Ein typischer Funktionskopf sieht folgendermaßen aus:

int Summe(int a, int b)

Als Parameter bezeichnet man im engeren Sinn nur die Deklaration des zu übergebenden Datentyps. Der eigentliche Wert, den die aufrufende Funktion übergibt, heißt Argument. Viele Programmierer machen keinen Unterschied zwischen den Begriffen »Parameter« und »Argument«, während andere genau auf diese technische Unterscheidung achten. Im Buch kommen beide Ausdrücke gleichberechtigt vor.

Der Rumpf einer Funktion besteht aus einer öffnenden geschweiften Klammer, einer beliebigen Zahl von Anweisungen (0 oder mehr) und einer schließenden geschweiften Klammer. Die Anweisungen erledigen die Arbeit der Funktion. Eine Funktion kann einen Wert mit der Anweisung return zurückgeben. Diese Anweisung bewirkt auch das Verlassen der Funktion. Wenn man keine return-Anweisung vorsieht, liefert die Funktion am Ende automatisch void zurück. Der zurückgegebene Wert muß dem im Funktionskopf deklarierten Typ entsprechen.

Eine ausführliche Besprechung der Funktionen finden Sie in Kapitel 5, »Funktionen«. Die Typen, die von einer Funktion zurückgeliefert werden können, werden im einzelnen in Kapitel 3, »Variablen und Konstanten«, besprochen. Die Informationen, die Sie heute erhalten, sollen als Überblick dienen, denn Funktionen sind Bestandteil fast eines jeden C++-Programms.

Listing 2.5 zeigt eine Funktion, die zwei ganzzahlige Parameter übernimmt und einen ganzzahligen Wert zurückgibt. Kümmern Sie sich momentan nicht um die Syntax oder die Einzelheiten, wie man mit Integer-Werten (beispielsweise int x) arbeitet. Wir kommen in Kapitel 3 darauf zurück.

Listing 2.5: FUNC.CPP demonstriert eine einfache Funktion

 1:    #include <iostream.h>
2: int Add (int x, int y)
3: {
4:
5: cout << "In Add(), erhalten " << x << " und " << y << "\n";
6: return (x+y);
7: }
8:
9: int main()
10: {
11: cout << "Ich bin in main()!\n";
12: int a, b, c;
13: cout << "Geben Sie zwei Zahlen ein: ";
14: cin >> a;
15: cin >> b;
16: cout << "\nAufruf von Add()\n";
17: c = Add(a,b);
18: cout << "\nZurueck in main().\n";
19: cout << "c wurde gesetzt auf " << c;
20: cout << "\nBeenden...\n\n";
21: return 0;
22: }

Ich bin in main()!
Geben Sie zwei Zahlen ein: 3 5

Aufruf von Add()
In Add(), erhalten 3 und 5

Zurueck in main().
c wurde gesetzt auf 8
Beenden...

Zeile 2 definiert die Funktion Add(), die zwei ganzzahlige Parameter übernimmt und einen ganzzahligen Wert zurückgibt. Das Programm selbst beginnt in Zeile 9 und in Zeile 11, wo es eine Meldung ausgibt. Das Programm fordert den Benutzer zur Eingabe von zwei Zahlen auf (Zeilen 13 bis 15). Der Benutzer tippt die beiden Zahlen durch ein Leerzeichen getrennt ein und drückt die Eingabe-Taste. Die Funktion main() übergibt die beiden vom Benutzer eingegebenen Zahlen als Argumente in Zeile 17 an die Funktion Add.

Der Programmablauf verzweigt in die Funktion Add(), die in Zeile 2 beginnt. Die Parameter a und b werden ausgegeben und dann addiert. Zeile 6 übergibt das Ergebnis an den Aufrufer, und die Funktion kehrt zurück.

Die Zeilen 14 und 15 realisieren die Eingabe von Werten für die Variablen a und b über das Objekt cin, und cout schreibt die Werte auf den Bildschirm. Auf Variablen und andere Aspekte dieses Programms gehen wir demnächst ein.

Zusammenfassung

Das Problem, etwas so Schwieriges wie Programmieren zu lernen, besteht darin, daß alles was Sie lernen, eine Unmenge von weiterem Lernstoff zur Folge hat. In diesem Kapitel wurden die wesentlichen Teile eines einfachen C++-Programms vorgestellt. Eingeführt wurden auch der Entwicklungszyklus und eine Reihe von neuen Begriffen.

Fragen und Antworten

Frage:
Was bewirkt die Anweisung #include?

Antwort:
Es handelt sich um eine Direktive an den Präprozessor, der bei Ausführung des Compilers aufgerufen wird. Diese spezielle Direktive bewirkt, daß die nach dem Schlüsselwort include genannte Datei eingelesen wird - so als würde man sie an dieser Stelle in den Quellcode eintippen.

Frage:
Worin liegt der Unterschied zwischen den Kommentaren // und /*?

Antwort:
Der Wirkungsbereich eines Kommentars mit doppelten Schrägstrichen (//) erstreckt sich nur bis zum Zeilenende. Die Kommentare mit Schrägstrich und Sternchen gelten solange, bis das Abschlußzeichen des Kommentars (*/) erscheint. Denken Sie daran, daß ein Kommentar mit /* nicht einfach durch das Ende einer Funktion abgeschlossen wird. Bei derartigen Kommentaren muß man immer das Abschlußzeichen schreiben, da man ansonsten einen Fehler zur Kompilierzeit erhält.

Frage:
Was unterscheidet einen guten von einem schlechten Kommentar?

Antwort:
Ein guter Kommentar sagt dem Leser, warum die betreffende Codestelle etwas tut oder welcher Codeabschnitt für was verantwortlich ist. Ein schlechter Kommentar wiederholt lediglich, was eine bestimmte Codezeile bewirkt. Die Codezeilen sollten so geschrieben sein, daß sie für sich selbst sprechen: Allein aus der niedergeschriebenen Anweisung sollte ohne weitere Kommentare ersichtlich sein, was der Code ausführt.

Workshop

Der Workshop enthält Quizfragen, die Ihnen helfen sollen, Ihr Wissen zu festigen, und Übungen, die Sie anregen sollen, das eben Gelernte umzusetzen und eigene Erfahrungen zu sammeln. Versuchen Sie, das Quiz und die Übungen zu beantworten und zu verstehen, bevor Sie die Lösungen in Anhang D lesen und zur Lektion des nächsten Tages übergehen.

Quiz

  1. Was ist der Unterschied zwischen einem Compiler und einem Präprozessor?
  2. Warum nimmt die main()-Funktion einen Sonderstatus ein?
  3. Wie sehen die zwei Möglichkeiten zur Kommentierung aus und worin unterscheiden sie sich?
  4. Können Kommentare verschachtelt sein?
  5. Können Kommentare länger als eine Zeile sein?

Übungen

  1. Schreiben Sie ein Programm, das »Ich liebe C++« auf dem Bildschirm ausgibt.
  2. Schreiben Sie das kleinstmögliche Programm, das kompiliert, gelinkt und gestartet werden kann.
  3. FEHLERSUCHE: Geben Sie das nachfolgende Programm ein und kompilieren Sie es. Warum funktioniert es nicht? Wie können Sie den Fehler beheben?
    1: #include <iostream.h>
    2: int main()
    3: {
    4: cout << Ist hier ein Fehler?";
    5: return 0;
    6: }



vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbacknächstes Kapitel


© Markt&Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH