Kommentare in C++
Kommentare erlauben es, Programme durch Erläuterungen verständlicher zu machen oder wichtige Notizen oder Hinweise an Bearbeiter an den passenden Stellen in einem Programm festzuhalten.
In C++ -Programme können Kommentare eingefügt werden.
Kommentare können (außerhalb eines Kommentars und eines Zeichenfolgenliterals) an jeder Stelle, an der auch Leerraum stehen dürfte, mit dem Zeichenpaar »/*« eingeleitet werden, sie enden mit dem ersten folgenden Zeichenpaar »*/«. Solche Kommentare können auch mehrere Zeilen umfassen.
Das Zeichen »/« wird „Schrägstrich“ genannt.
Das Zeichen »*« wird „Stern“ (oder „Sternchen“) genannt.
Das Zeichenpaar »/*« muß zur Einleitung eines Kommentars genau so geschrieben werden (es darf kein Leerraum eingefügt werden), genauso muß das Zeichenpaar »*/« zum Abschluß eines Kommentars genau so geschrieben werden (es darf kein Leerraum eingefügt werden).
Innerhalb eines Kommentars hat das Zeichenpaar »/*« keine besondere Bedeutung.
Der in einem Kommentar enthaltene Text wird von einer C++ -Implementation im allgemeinen ignoriert – ein Kommentar gilt effektiv als ein Leerraum. Daher können Kommentare verwendet werden, um irgendwelche Notizen in ein Programm zu schreiben oder auch um lexikalische Einheiten zu trennen.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << - -65/* Brot kaufen! Lehmann anrufen! */ << "\n"s; }
::std::cout65
Kommentare dürfen auch über mehrere Zeilen gehen.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << - -65/*
Brot kaufen!
Lehmann anrufen!
*/ << "\n"s; }::std::cout65
Kommentare werden am Anfang der Verarbeitung eines Programms praktisch durch ein Leerzeichen ersetzt. Daher können sie auch zum Trennen lexikalischer Einheiten verwendet werden.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << -/* Vorzeichenwechsel*/-65 << "\n"s; }
::std::cout65
Entfernte man den Kommentar in dem obigen korrekten Programm, so erhielte man das folgende fehlerhafte Programm.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << --65 << "\n"s; }
- Fehlermeldung (gekürzt)
error: lvalue required
int main() { ::std::cout << --65 << "\n"s; }
^
Kommentare werden vor der weiteren Verarbeitung eines Quelltextes bei der Übersetzung aber praktisch durch ein Leerzeichen ersetzt. Aus dem obigen Programm mit einem Kommentar wird also das folgende Programm gemacht.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << - -65 << "\n"s; }
::std::cout65
Da ein Kommentar mit dem ersten Zeichenpaar »*/« endet, kann man Kommentare nicht „verschachteln“. Im folgenden Beispiel endet der Kommentar also bereits mit »def */«.
- Ein Kommentar mit einem ihm folgenden Text » ghi */«
/* abc /* def */ ghi */
Zeilenendkommentare
Es gibt auch eine andere Schreibweise für Kommentare: Durch das Zeichenpaar »//« wird Text bis zum Ende der Zeile als Kommentar gekennzeichnet. (Zwischen den beiden Schrägstrichen darf in diesem Zeichenpaar kein Leerraum stehen.)
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout <<
-65 // Vorzeichenwechsel
<< "\n"s; }::std::cout-65
Innerhalb eines solchen Kommentars haben die Zeichenpaare »/*«, »*/« und »//« keine besondere Bedeutung.
Übungsfrage ⃗
- / Kommentare zählen
- Ist das folgende Programm korrekt, und, wenn ja: wie viele Kommentare finden sich darin?
#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << 65/* alpha /* // /** gamma */ << "\n"s; }
Robustheit von Kommentaren *
Bei der Darstellung oder Übermittlung von Programmen werden lange Zeilen manchmal neu umbrochen. Dadurch kann es passieren, daß ein Teil eines Zeilenendkommentars plötzlich am Anfang der nächsten Zeile landet und das Programm dann nicht mehr korrekt ist.
Main.txt#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout <<
-65 //
Vorzeichenwechsel
<< "\n"s; }
Die Struktur von Zeilenendkommentaren folgt nicht der üblichen Regelung, derzufolge im Quelltext ein Leerzeichen durch ein Zeilenende ersetzt werden kann, ohne daß dies die Bedeutung des Quelltextes verändern. Traditionalle Kommentare sind gegenüber einem unbeabsichtigten Umbruch robuster, weil sie der genannten Regelung entsprechen.
Main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout <<
-65 /*
Vorzeichenwechsel */
<< "\n"s; }::std::cout-65
Zeichenfolgenliterale *
Die Kommentareinleiter »/*« und »//« leiten innerhalb einem Zeichenfolgenliterals keinen Kommentar ein, sondern gelten dann auch als Teil der Zeichenfolge.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << "ABC/*DEF//GHI"s << "\n"s; }
::std::coutABC/*DEF//GHI
Umgekehrt gelten Anführungszeichen in Kommentaren nicht als Beginn eines Zeichenfolgenliterals.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << 2/*"*/ << "\n"s; }
::std::cout2
Kommentardiagramm für Kommentare *
Die folgenden Kommentardiagramme beschreiben Kommentare.
Ein Kommentardiagramm ist genauso zu verstehen, wie ein morphologisches Diagramm. Wir nennen es aber nicht „morphologisches Diagramm“, da morphologische Diagramme lexikalische Einheiten beschreiben und ein Kommentar keine lexikalische Einheit ist. Kommentardiagramme werden in diesem Kurs mit »|/|« gekennzeichnet.
Kommentar
.-. .-. .-------------.
|/|--->( / )--->.--->( / )----.------------------------.--->| Zeilenende |--->.---->|/|
'-' | '-' ^ | '-------------' ^
| | .---------------. | |
| | | jedes Zeichen | | |
| '---| ausser einem |<---' |
| | Zeilenende | |
| '---------------' |
| |
| .---------------. |
| | jedes Zeichen | |
| .---| ausser "*" |<--------. |
| | | und "/" | | |
| | '---------------' | |
| .-. v | |
'--->( * )--->'---------------------------->' |
'-' | ^ ^ |
| | | |
v | | |
.<-----------. | |
| | | |
v .-. | | |
'--->( / )---' .------------. |
| '-' | | |
| | | |
| v .-. | .-. |
'--------------->'--->( * )---'---( / )----------'
'-' '-'
„Auskommentieren“ von Quelltext *
Auch Quelltext kann in einem Kommentar enthalten sein. Der Quelltext wird dann vom Compiler ignoriert. Man nennt ihn auskommentiert.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << 65 << "\n"s; }
/*
// fruehere Programmversion vom 4. Dezember 2033 (hier auskommentiert):
#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << 56 << "\n"s; }
*/- Was der Compiler davon sieht:
#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << 65 << "\n"s; }
Jedoch ist es nicht möglich, mit einem /*-Kommentar Programme auszukommentieren, die selber /*-Kommentare enthalten, da /*-Kommentare nicht verschachtelt werden dürfen (weil das erste »*/« den Kommentar immer beendet). Hier muß dann auf //-Kommentare ausgewichen werden:
main.cpp#include <iostream>
#include <ostream>int main() { ::std::cout << 65 << "\n"s; }
// /* fruehere Programmversion vom 4. Dezember 2033 */
// #include <iostream>
// #include <ostream>// int main() { ::std::cout << 56 << "\n"s; }
- Was der Compiler davon sieht:
#include <iostream>
#include <ostream>int main() { ::std::cout << 65 << "\n"s; }