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,
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()
alsvoid
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 vonmain()
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.
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
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!
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.
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.
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.
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.
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 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.
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.
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.
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.
main()
-Funktion einen Sonderstatus ein?
1: #include <iostream.h>
2: int main()
3: {
4: cout << Ist hier ein Fehler?";
5: return 0;
6: }
Beseitigen Sie den Fehler in Übung 3, kompilieren und linken Sie das Programm neu, und starten Sie es noch einmal.
© Markt&Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH