Zeichenfolgenliterale in C++
Das folgende Programm zeigt, wie ein Text mit Hilfe von Anführungszeichen »"« angegeben wird.
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << "Hallo, Welt"s << "\n"s; }
::std::coutHallo, Welt
Aufbau von Zeichenfolgenliteralen
Ein Zeichenfolgenliteral besteht (etwas vereinfacht gesagt) aus einem Anführungszeichen, eine beliebigen Anzahl von Zeichen, einem weiteren Anführungszeichen und einem »s«. Beispielsweise: »"abc"s« (Anführungszeichen, a, b, c, Anführungszeichen, s).
- Aufbaudiagramm
Zeichenfolgenliteral (vereinfacht)
.-. .-. .-.
|-|--->( " )---.------------------.--->( " )--->( s )--->|-|
'-' ^ | '-' '-'
| .---------. |
'---| Zeichen |<---'
'---------'
Das kleine »s« am Ende eines Zeichenfolgenliterals leitet sich vom englischen Wort “string ” („Zeichenfolge“) ab.
Ein Zeichenfolgenliteral ist ein Ausdruck.
Semantik von Zeichenfolgenliteralen
Die Semantik ist der Teil einer Programmiersprache, welcher erklärt, wie die Bedeutung eines Programms ermittelt wird. In unserem Fall legt die Semantik fest, wie die Zeichenfolge (der Wert) eines Zeichenfolgenliterals bestimmt wird.
Semantik: Die Zeichenfolge eines Zeichenfolgenliterals ist die in ihm zwischen den Anführungszeichen enthaltene Zeichenfolge.
- Zeichenfolgenliteral
"Hallo, Welt"s
- Bedeutung des Zeichenfolgenliterals (Zeichenfolge)
Hallo, Welt
Die Zeichenfolge »Hallo, Welt« kann natürlich auch durch eine andere Zeichenfolge ersetzt werden, wie das folgende Programmbeispiel zeigt.
- Zeichenfolgenliteral
"Alpha"s
- Bedeutung des Zeichenfolgenliterals (Zeichenfolge)
Alpha
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << "Alpha"s << "\n"s; }
::std::coutAlpha
Zeichenfolgen mit einem einzigen Zeichen
Auch eine Folge mit nur einem einzigen Schriftzeichen gilt als Zeichenfolge.
- Zeichenfolgenliteral
"A"s
- Bedeutung des Zeichenfolgenliterals (Zeichenfolge)
A
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << "A"s << "\n"s; }
::std::coutA
Die leere Zeichenfolge
Sogar eine Folge ohne Schriftzeichen gilt als Zeichenfolge.
- Zeichenfolgenliteral (leer)
""s
- Bedeutung des Zeichenfolgenliterals (leere Zeichenfolge)
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << ""s << "\n"s; }
::std::cout
Zeilenenden
Das Zeichen »\« heißt „inverser Schrägstrich“.
In einem Zeichenfolgenliteral steht das Zeichenpaar »\n« für ein Zeilenende in der dargestellten Zeichenfolge. (Genau genommen, trifft dies nicht immer zu, aber für die ersten Schritte beim Programmieren reicht diese etwas vereinfachte Erklärung.)
main.cpp#include <iostream>
#include <ostream>
#include <string>using namespace ::std::literals;
int main() { ::std::cout << "Alpha\nGamma"s << "\n"s; }
::std::coutAlpha
Gamma
C -Zeichenfolgenliterale in diesem Kurs
Neben den mit einem »s« endenden C++ -Zeichenfolgenliteralen wie »"abc"s« gibt es in C++ auch noch die Zeichenfolgenliterale der C++ zugrundeliegenden Programmiersprache C wie »"abc"«, bei welchen das »s« entfällt. In diesem Kurs sollen zur Vereinfachung und der Einheitlichkeit halber bis auf weiteres nur die C++ -Zeichenfolgenliteralen wie »"abc"s« verwendet werden. Einige Lektionen enthalten aber derzeit noch die C -Zeichenfolgenliterale, weil sie in früheren Versionen dieses Kurses verwendet wurden und noch nicht alle Lektionen dieses Kurses umgestellt wurden.
- Aufbaudiagramm
C-Zeichenfolgenliteral (vereinfacht)
.-. .-.
|-|--->( " )---.------------------.--->( " )--->|-|
'-' ^ | '-'
| .---------. |
'---| Zeichen |<---'
'---------'
Falls der Leser ein Programm mit C -Zeichenfolgenliteralen wie »"abc"« selber auf die C++ -Zeichenfolgenliteralen wie »"abc"s« umstellen will, so ist dies in der Regel dadurch möglich, daß ein »s« an die Zeichenfolgenliterale angehangen und sichergestellt wird, daß vor »int main()« die beiden Zeilen »#include <string>« und »using namespace ::std::literals;« stehen, so wie dies in den obenstehenden Programmen zu sehen ist.
Das folgende Beispiel zeigt ein Programm mit den C -Zeichenfolgenliteralen ohne »s«.
main.cpp#include <iostream>
#include <ostream>int main() { ::std::cout << "A" << "\n"; }
::std::coutA
Das Programm mit den C -Zeichenfolgenliteralen wirkt zunächst einfacher, weil es kürzer ist. Da die C++ -Zeichenfolgenliterale aber besser zur Programmiersprache C++ passen, ist es insgesamt doch einfacher und einheitlicher im Kurs zunächst nur diese zu verwenden, auch wenn die Programme etwas länger werden.
Bei Verwendung alter C++ -Implementation, welche die mit einem »s« endenden C++ -Zeichenfolgenliteralen wie »"abc"s« noch nicht kennen, können die meisten Programme aus dem Kurs verwendet werden, indem »using namespace ::std::literals;« entfernt und das »s« am Ende der Zeichenfolgenliterale entfernt wird.
Außerdem ist es Kursteilnehmern freigestellt, bei der Bearbeitung von Übungsaufgabe die zunächst einfacher verwendbaren C -Zeichenfolgenliterale wie »"abc"« einzusetzen, falls die zusätzlichen Möglichkeiten der mit einem »s« endenden C++ -Zeichenfolgenliteralen wie »"abc"s« nicht benötigt werden.
Übungsfragen
Textangaben in chevrons (/ʃə.vʁɔ̃s/), also den Zeichen "»" und "«", beziehen sich immer auf den Text zwischen diesen chevrons. Beispielsweise umfaßt der Text »abc« drei Zeichen (nicht fünf).
? Übungsfrage
Wie viele Zeichen hat die vom Zeichenfolgenliteral »"ab"s« dargestellte Zeichenfolge?
? Übungsfrage
Wie viele Zeichen hat das Zeichenfolgenliteral »"ab"s« selber (als Zeichenfolgenliteral)?
Sonderzeichen *
Einige Sonderzeichen können nicht direkt in Zeichenfolgenliteralen enthalten sein. Wir verzichten in diesem Teil des Kurses zur Vereinfachung darauf, dieses Thema zu vertiefen.