C++ Tutorial

String-Objekte I

string-Datentyp

Für die Bearbeitung von Strings stellt die C++-Standardbibliothek den Datentyp string zur Verfügung. Er ist in der Header-Datei <string> definiert liegt ebenfalls im Namensraum std.

Gegenüber der Ablage von C-Strings in Feldern bietet er u.a. folgende Vorteile:

Es wird stets genügend Speicher reserviert, um eine beliebig lange Zeichenfolge ablegen zu können.
Es stehen diverse Operatoren zur Verfügung, um Strings auf einfache Art und Weise bearbeiten zu können. So fügt zum Beispiel der Operator + zwei Strings zusammen.

Der Datentyp string enthält wesentlich mehr Funktionalität, als in dieser ersten Einführung aufgezeigt wird. Da aber noch einige Grundlagen fehlen, wird auf diesen Datentyp in einem späteren Kapitel String-Objekte II nochmals eingegangen.

Damit in Zukunft keine Verwirrung bezüglich des Begriffs String entsteht, wird im weiteren Verlauf unter einem String immer ein string-Objekt verstanden. Zeichenfolgen, die in einem char-Feld abgelegt sind, werden als C-String bezeichnet.

String definieren

Prinzipiell wird ein String auf die gleiche Art und Weise definiert wie eine Variable.

std::string sName;

sName ist der Name des string-Objekts. Ein auf diese Weise definierter String ist leer.

Um einen String bei seiner Definition mit einer Zeichenfolge zu initialisieren, folgt nach dem Namen des string-Objekts

entweder der Zuweisungsoperator und eine in Anführungszeichen eingeschlossene Zeichenfolge oder
eine runde oder geschweifte Klammer und darin, ebenfalls in Anführungszeichen eingeschlossen, die Zeichenfolge.

Beide Verfahren sind gleichwertig und führen zum Aufruf des sogenannten Konstruktors des string-Objekts. Was ein Konstruktor ist und welche Aufgabe er hat, wird im Kapitel Konstruktor und Destruktor behandelt. Für den Augenblick soll die Aussage genügen, dass der Konstruktor das string-Objekt mit der übergebenen Zeichenfolge initialisiert.

Wie im Kapitel Literale (unbenannte Konstanten) erwähnt, ist der Datentyp eines C-String-Literals char-Feld mit n konstanten Zeichen. Um explizit ein String-Literal zu definieren, folgt nach dem abschließenden Anführungszeichen das Suffix s. Und damit der Compiler das Suffix s kennt, ist dieses mittels using namespace std::string_literals; einzubinden.

Wird eine auto-Variable mit einer Zeichenfolge ohne das Suffix s initialisiert, ist der Datentyp der auto-Variable standardmäßig ein const char*. Soll die auto-Variable vom Typ string sein, muss die Zeichenfolge mit dem Suffix s gekennzeichnet werden.

Und selbstverständlich kann auch vom Datentyp string ein Feld definiert werden, das n Strings aufnimmt, die unterschiedliche Längen besitzen können. Dies darf nicht mit der Definition eines char-Feldes verwechselt werden

1:	// Header-Datei für string einbinden
2:	#include <string>
3:	// Suffix s fuer string einblenden
4:	using namespace std::string_literals;
5:	
6:	// Leeren String definieren
7:	std::string empty;
8:	// String mit C-String initialisieren
9:	std::string text1 = "Ein C-String";
10:	// String-Feld definieren
11:	std::string array[10];
12:	// und ersten Element einen C-String zuweisen
13:	array[0] = "String-Element 0";
14:	// String mit string-Literal initialsieren
15:	std::string text3 {"Ein String"s};
16:	// String mit einem anderen String initialisieren
17:	std::string text2(text1);

Die C++-Standardbibliothek kennt weitere Methoden, um ein string-Objekt zu erstellen. Für unsere Zwecke sollen diese Möglichkeiten vorerst ausreichen.

Ein- und Ausgabe eines Strings

Die Ausgabe eines Strings unterscheidet sich nicht von der Ausgabe anderer Daten, d.h., der String wird direkt in den Ausgabestream einfügt.

1:	#include <iostream>
2:	#include <string>
3:	#include <print>
4:	// Suffix s fuer string einblenden
5:	using namespace std::string_literals;
6:	
7:	int main()
8:	{
9:     auto text = "Ein string-Objekt"s;
10:    std::cout << text << '\n';
11:    std::println("Text: {}", text);
12:	}

Beim Einlesen ist zu unterscheiden, ob die Wörter der Eingabe in getrennten Strings abzulegen sind oder die gesamte Eingabe in einem String.

Um mehrere Wörter einer Eingabe in getrennten Strings abzulegen, sind entsprechend viele string-Objekte beim Einlesen anzugeben.

1:	#include <iostream>
2:	#include <string>
3:	
4:	int main()
5:	{
6:    std::string word1, word2;
7:    std::cin >> word1 >> word2;
8:	}

Soll dagegen eine ganze Zeile in einem String abgelegt werden, ist hierfür die Funktion std::getline() einzusetzen.

1:	#include <iostream>
2:	#include <string>
3:	
4:	int main()
5:	{
6:    std::string line;
7:    std::getline(std::cin,line);
8:	}

getline() enthält im ersten Parameter eine Referenz auf den Stream, aus dem die Zeile eingelesen wird. Im Beispiel ist dies der Eingabestream cin. Ebenso wäre hier z.B. die Angabe eines Dateistreamobjekts vom Typ ifstream möglich. Der zweite Parameter ist eine Referenz auf das string-Objekt, in dem die Eingabe abgelegt wird.

String-Operationen

Zuweisungen

Die einfachste Operation ist die Zuweisung. Mit ihr wird einem String ein (C-)String-Literal, eine (C-)String-Konstante oder ein weiterer String zugewiesen.

1:	// Zwei Strings definieren
2:	std::string s1, s2;
3:	// C-String-Literal einem String zuweisen
4:	s1 = "Dies ist String1";
5:	// String einem anderen String zuweisen
6:	s2 = s1;

Addition

Strings werden mit dem Operator + bzw. =+ 'addiert', d.h. aneinandergehängt.

1:	// Drei Strings definieren
2:	std::string s1("Text1"), s2, s3;
3:	// C-String-Literal addieren, s1 danach "Text1 erweitert"
4:	s1 += " erweitert";
5:	// char* addieren, s2 danach "Text1 erweitert in s2"
6:	s2 = s1 + " in s2";
7:	// string addieren, s3 danach "Text1 erweitert in s3"
8:	s3 = s1 + " in s3"s;

Beachten Sie den Unterschied zwischen den Zeilen 6 und 8. In Zeile 6 wird ein const char* addiert und in Zeile 8 ein string.

Zeichen-Zugriff und Stringlänge

Um auf einzelne Zeichen innerhalb eines Strings zuzugreifen, wird der Indexoperator [ ] verwendet. Auch hier hat das erste Zeichen im String den Index 0. Soll der gesamte String durchlaufen werden, liefert die Methode size() die Anzahl der Zeichen im String als size_t-Datum. Einfacher geht es mit einer range-for Schleife, um einen String sequenziell zu durchlaufen.

1:	// String definieren und initialisieren
2:	std::string s1("Ein Text");
3:	// Alle Zeichem im String einzeln ausgeben
4:	for (size_t i=0Z; i<s1.size(); i++)
5:    std::print("{}, ",s1[i]);
6:	// Zugriff mittels range-for
7:	for (auto zeichen: s1)
8:    std::print("{}, ",zeichen);

Microsoft Visual Studio 2022 kennt das Suffix Z in Zeile 4 noch nicht. Lassen Sie das Suffix Z einfach weg, der Compiler führt in diesem Fall eine implizite Typkonvertierung von int nach size_t durch.

Strings vergleichen

Strings können mit den bekannten Vergleichsoperatoren <, >, == usw. verglichen werden. Der Vergleich erfolgt lexikografisch, d.h., 'Aaaa' ist kleiner als 'Bb'. Einer der beiden Operanden des Vergleichsoperators kann anstelle eines string-Objekts ein const char-Zeiger sein.

1:	// Zwei String definieren und initialisieren
2:	std::string s1("Aaaa"), s2("Bb");
3:	// Strings vergleichen
4:	if (s1 < s2)
5:    std::cout << "s1 kommt vor s2\n";
6:	else
7:    std::cout << "s2 kommt vor s1\n";

char-Zeiger Konvertierung

Die Methode c_str() liefert einen const char-Zeiger auf die im string abgelegte Zeichenfolge. Mithilfe dieser Konvertierung kann überall dort ein String verwendet werden, wo ansonsten ein const char-Zeiger benötigt wird. Es ist zu beachten, dass die Methode c_str() einen const char* liefert und der Inhalt des Strings darüber nicht verändert werden kann. Im Beispiel wird damit der Inhalt eines Strings in ein char-Feld kopiert.

1:	// String definieren und initialisieren
2:	std::string s1("Ein Text");
3:	// char-Feld definieren
4:	char charArray[40];
5:	// Zeichen aus String in char-Feld umkopieren
6:	strcpy_s(charArray,sizeof charArray, s1.c_str());

Der umgekehrte Weg, also einen char-Zeiger in einen String zu konvertieren, erfolgt entweder über die Definition eines Strings oder über den Zuweisungsoperator.

Der string-Datentyp enthält, wie erwähnt, weitere Methoden, um z.B. Zeichen in einen String einzufügen oder zu löschen. Diese Methoden werden später im Kapitel String-Objekte II behandelt.

string_view

Ein string_view definiert eine Sicht auf einen bestehenden (C-)String. Wird string_view verwendet, ist die Header-Datei <string_view> einzubinden. Und wie alle Klassen der Standardbibliothek liegt auch er im Namensraum std.

Ein string_view kann bei seiner Definition u.a. mit einem C-String oder einem String initialisiert werden.

1:	// C-String und String definieren
2:	const char cstring[] = { "Ein C-String" };
3:	std::string cppstring{ "Ein C++-String" };
4:	// string_views auf die Strings
5:	std::string_view sv1{ cstring };
6:	std::string_view sv2{ cppstring };
7:	// Leeren string_view definieren und die Sicht per 
8:	// Zuweisung auf einen String setzen
9:	std::string_view sv3;
10:	sv3 = cstring;

Welchen Vorteil bietet ein string_view, wenn er nur eine Sicht ist? Die Antwort darauf lautet: Performance. Sehen Sie sich dazu folgendes Beispiel an:

1:	#include <iostream>
2:	#include <string>
3:	#include <string_view>
4:	
5:	void SRPrint(const std::string& s)
6:	{
7:    std::cout << s;
8:	}
9:	
10:	void SVPrint(std::string_view s)
11:	{
12:    std::cout << s;
13:	}
14:	
15:	int main()
16:	{
17:    SRPrint("Ein Text");
18:    SVPrint("Ein Text");
19:	}

Die Funktion SRPrint() erhält als Parameter eine Referenz auf ein konstantes string-Objekt und die Funktion SVPrint() einen string_view. Da die Funktion SRPrint() ein string-Objekt erwartet, wird vor dem Aufruf der Funktion ein string-Objekt instanziiert und der C-String in das string-Objekt übernommen. Anschließend wird die Funktion ausgeführt. Nach der Rückkehr aus der Funktion wird das string-Objekt nicht weiter benötigt und gelöscht. Wird statt eines string-Objekts ein string_view übergeben, erhält die Funktion einen Verweis auf den übergebenen String, womit der Kopiervorgang entfällt. Die einzige Einschränkung dabei ist, dass der String in der Funktion nicht verändert werden kann.

Der Einsatz eines string_views bietet also sich immer dann an, wenn eine Funktion als Parameter einen C-String oder String erwartet der in der Funktion nicht verändert wird.

Der Zugriff auf Zeichen im string_view erfolgt wie beim string über den Indexoperator [ ].

Der Datentyp string_view besitzt weitere Methoden, um z.B. einen Teilstring in einem string-Objekt zu finden. Diese werden ebenfalls später behandelt.

Hier folgen in der Offline-Version die Übungen.

String-Konvertierungen

String in numerische Werte

Für die Konvertierung von in einem String enthaltenen Daten in ihre numerische Werte stehen mehrere Verfahren zur Verfügung. Wir sehen uns das effizienteste Verfahren dazu an, die Konvertierung mittels der Bibliotheksfunktion from_chars(). from_chars() ist in der Header-Datei <charconv> definiert und liegt wiederum im Namensraum std.

Wenn Sie sich die anderen Verfahren ansehen wollen, suchen Sie auf https://en.cppreference.com nach std::from_chars(). Ganz unten auf der Seite sind ebenfalls die anderen Verfahren aufgeführt.

Integer-Konvertierung

Die Syntax, um ein Integer-Datum in einem String in seinen numerischen Wert zu konvertieren, ist wie folgt:

std::from_chars_result std::from_chars(const char* first,            const char* last,
                                       DTYP& value,            int base = 10);

first verweist auf den Beginn des zu konvertierenden Datums und last auf dessen Ende. Das Ergebnis der Konvertierung wird in der Variablen value abgelegt. Und je nach Datentyp DTYP der Variable wird der Stringinhalt in einen entsprechenden Integerwert konvertiert, z.B. in einen int- oder unsigned long-Wert. Der letzte Parameter base gibt an, zu welcher Basis der Inhalt des Strings zu interpretieren ist. Zulässig sind Werte zwischen 2 und 36.

Als Rückgabe liefert from_chars() eine Struktur (Struktur wird später erklärt) vom Datentyp from_chars_result mit den Eigenschaften ec und ptr. Bei erfolgreicher Konvertierung enthält die Eigenschaft ec den Wert std::errc() und im anderen Fall einen Fehlercode. Die Eigenschaft ptr enthält einen Verweis auf die nächste, nicht-konvertierte Position innerhalb des Strings.

Wie mehrere Daten in einem String konvertiert werden, ist im nachfolgenden Beispiel dargestellt.

1:	#include <print>
2:	#include <string>
3:	#include <charconv>
4:	using namespace std::string_literals;
5:	
6:	int main()
7:	{
8:     // String mit dezimal, hex und binaer Zahlen
9:     std::string toConv{"123 FFFF 10000000"s};
10:	
11:    // Variablen fuer die Ergebnisse der Konvertierung
12:    int iVal;
13:    unsigned long lVal;
14:    unsigned char cVal;
15:	
16:    // "Dezimal-String" (3 Stellen) nach int
17:    auto res = std::from_chars(toConv.c_str(),
18:                              toConv.c_str() + 3, iVal);
19:    // Pruefen, ob Konvertierung erfolgreich und
20:    // konvertierten Wert ausgeben
21:    if (res.ec == std::errc())
22:       std::print("{}, ",iVal);
23:	
24:    // "Hex-String" (4 Digits) nach unsigned long
25:    // Start und Ende werden ueber den von from_char()
26:    // zurueckgelieferten Zeiger definiert, wobei das
27:    // Leerzeichen uebersprungen wird
28:    res = std::from_chars(res.ptr+1,res.ptr+5,lVal,16);
29:    // Pruefen und ausgeben des Wertes
30:    if (res.ec == std::errc())
31:       std::print("{}, ",lVal);
32:	
33:    // "Binaer-String" (8 Digits) nach unsigned char
34:    res = std::from_chars(res.ptr+1,res.ptr+9,cVal,2);
35:    // Pruefen und ausgeben des Wertes
36:    if (res.ec == std::errc())
37:       std::println("{:d}",cVal);
38:	}

123, 65535, 128

Ein zu konvertierender Hex-String darf kein Präfix 0x oder 0X als Kennzeichnung enthalten.

Gleitkomma-Konvertierung

Für die Konvertierung eines Gleitkomma-Datums in einem String wird ebenfalls die Funktion from_chars() verwendet, jedoch mit abweichenden Parametern. Die Funktion besitzt folgende Deklaration:

std::from_chars_result std::from_chars(const char* first,
                                       const char* last, DTYP& value,
                                       std::chars_format fmt = std::chars_format::general);

first und last zeigen wieder auf den zu konvertierenden Bereich und DTYP ist einer der Gleitkomma-Datentypen. fmt bestimmt, wie der zu konvertierende String zu interpretieren ist. In der Regel kann dieser Parameter beim Aufruf entfallen, d.h., die Funktion wird mit dem Argument chars_format::general aufgerufen. Als Rückgabe liefert die Funktion wieder eine Struktur from_chars_result.

1:	#include <print>
2:	#include <string>
3:	#include <charconv>
4:	using namespace std::string_literals;
5:	
6:	int main()
7:	{
8:     std::string sf1{ "12.34e-01"s };   // Gleitkomma-Strings
9:     std::string sf2{ "3.1416"s };
10:	
11:    // Variablen fuer das Ergebnis der Konvertierung
12:    float fVal;
13:    double dVal;
14:	
15:    // Strings konvertieren
16:    auto res = std::from_chars(sf1.c_str(),
17:                               sf1.c_str() + sf1.size(), fVal);
18:    if (res.ec == std::errc())
19:       std::println("{}",fVal);
20:	
21:    res = std::from_chars(sf2.c_str(),
22:                         sf2.c_str() + sf2.size(), dVal);
23:    if (res.ec == std::errc())
24:       std::println("{}",dVal);
25:	}

1.234
3.1416

Mehrere Werte konvertieren

Um mehrere Daten in einem String in einer Anweisung zu konvertieren, kann alternativ der Stream istringstream verwendet werden, der in der Header-Datei <sstream> definiert ist. Diese Konvertierung ist von der Laufzeit her langsamer als die Konvertierung mittels from_chars(), jedoch weniger fehleranfällig da die Positionen der Daten im String nicht beachtet werden müssen.

Für die Konvertierung ist zunächst ein istringstream-Objekt zu definieren. Diesem Objekt wird mit der Methode str() der zu konvertierende String übergeben. Und ab diesem Zeitpunkt verhält sich istringstream genauso wie der Eingabestream cin, d.h. mithilfe des Operators >> werden die einzelnen Wörter bzw. Werte aus dem Stream extrahiert. Im nachfolgenden Beispiel enthält am Ende die Variable intVar1 den Wert 123, intVar2 den Wert 456 und dblVar den Wert 3.4.

1:	// Header-Datei für istringstream einbinden
2:	#include <sstream>
3:	// Suffix s fuer string einblenden
4:	using namespace std::string_literals;
5:	...
6:	// Streamobjekt definieren
7:	std::istringstream is;
8:	// string definieren und initialisieren
9:	auto s1 = "123 456 3.4"s;
10:	// String dem Streamobjekt uebergeben
11:	is.str(s1);
12:	// Variablen für die Konvertierung definieren
13:	int intVar1, intVar2;
14:	double dblVar;
15:	// Werte extrahieren
16:	is >> intVar1 >> intVar2 >> dblVar;

Alternativ kann das istringstream-Objekt bei seiner Definition mit einen (C-)String initialisiert werden.

Soll der Inhalt mehrerer Strings mit demselben istringstream-Objekt konvertiert werden, ist nach der Auswertung eines Strings die Methode clear() des istringstream-Objekts aufzurufen, um das Streamobjekt zurückzusetzen.

1:	// Header-Datei für istringstream einbinden
2:	#include <sstream>
3:	...
4:	// Streamobjekt definieren und initialisieren
5:	std::istringstream is("12 13");
6:	// String konvertieren
7:	int var1, var2;
8:	is >> var1 >> var2;
9:	// Status des Streamobjekts zurücksetzen
10:	is.clear();
11:	// Neuen C-String dem Streamobjekt zuweisen
12:	is.str("22 33");

Und da istringstream und cin vom gleichen Basisstream abstammen, stehen die gleichen Manipulatoren zur Verfügung. So werden im nachfolgenden Beispiel Hex-Daten aus einem String ausgelesen und in Variablen abgelegt. Das Hex-Präfix 0x.. darf im String optional vorhanden sein.

1:	// Header-Datei für istringstream einbinden
2:	#include <sstream>
3:	using namespace std::string_literals;
4:	...
5:	// Streamobjekt definieren
6:	std::istringstream is;
7:	// String dem Streamobjekt übergeben
8:	is.str("0x50 10"s);
9:	// String nach binär konvertieren
10:	int var1, var2;
11:	is >> std::hex >> var1 >> var2;
12:	std::println("{} {}\n",var1, var2);

80 16

Numerische Werte in einen C-String

Integer-Konvertierung

Um einen numerischen Wert in einen C-String umzuwandeln, kann die Funktion to_chars() angewandt werden, welche ebenfalls in der Header-Datei <charconv> und im Namensraum std definiert ist.

std::to_chars_result std::to_chars(char* first, char* last, DTYP value, int base = 10);

first verweist auf den Beginn des Bereichs, in dem der konvertierte Wert abgelegt wird, last auf dessen Ende und value enthält den zu konvertierenden Wert. Der letzte Parameter base legt fest, zu welcher Basis der Wert konvertiert wird. Zulässig sind wieder Werte zwischen 2 und 36.

Als Rückgabe liefert to_chars() ebenfalls eine Struktur, jetzt vom Datentyp to_chars_result. War die Konvertierung erfolgreich, enthält das Strukturelement ec den Wert std::err() und das Strukturelement ptr verweist auf die nächste nicht für die Konvertierung verwendete Position im C-String.

Der C-String mit dem konvertierten Wert wird nicht mit einer 0 abgeschlossen!

Gleitkomma-Konvertierung

Auch für diese Konvertierung wird die Bibliotheksfunktion to_chars() verwendet.

std::to_chars_result std::to_chars(char* first, char* last, DTYP value);

first und last verweisen wieder auf den Bereich, in dem der konvertierte Wert abgelegt wird und value ist das zu konvertierende Gleitkomma-Datum.

Von dieser Funktion gibt es zwei weitere Varianten, mit denen das Format und die Anzahl der Stellen für die Konvertierung definiert werden können.

1:	#include <print>
2:	#include <charconv>
3:	
4:	int main()
5:	{
6:     // Zu konvertierende Werte
7:     short sVal = 0x55;
8:     unsigned long lVal = 2'345'000UL;
9:     float fVal = 123.456f;
10:    // char-Feld zur Aufnahme des Strings
11:    constexpr int SIZE = 80;
12:    char conv[SIZE];
13:	
14:    // short-Wert nach String
15:    // Konvertierung in einen 'Binaerstring' (Basis 2)
16:    std::to_chars_result res;
17:    if (res = std::to_chars(conv, conv + SIZE, sVal, 2);
18:        res.ec != std::errc())
19:           std::println("Fehler Konvertierung {}", sVal);
20:	
21:    // long-Wert nach String
22:    // Konvertierung wird an vorherige angehaengt
23:    // Konvertierungen durch Komma trennen
24:    *(res.ptr) = ',';
25:    if (res = std::to_chars(res.ptr+1, conv + SIZE, lVal);
26:        res.ec != std::errc())
27:           std::println("Fehler Konvertierung {}", lVal);
28:	
29:    // float-Wert nach String
30:    // Konvertierung wird an vorherige angehaengt
31:    // Konvertierungen durch Zeilenvorschub trennen
32:    *(res.ptr) = '\n';
33:    if (res = std::to_chars(res.ptr + 1, conv + SIZE, fVal);
34:        res.ec != std::errc())
35:           std::println("Fehler Konvertierung {}\n", fVal);
36:    // Konvertierten String mit 0 abschliessen!
37:    *(res.ptr) = 0;
38:    std::println("{}",conv);
39:	}

1010101,2345000
123.456

Numerische Werte in einen String

Um numerischen Daten in einen String zu konvertieren, wird die Funktion std::format() verwendet. Sie liefert ein string-Objekt mit den konvertierten Werten.

1:	#include <iostream>
2:	#include <format>
3:	#include <string>
4:	
5:	int main()
6:	{
7:     // Zu konvertierende Werte
8:     short sVal = 0x55;
9:     unsigned long lVal = 2'345'000UL;
10:    float fVal = 123.456f;
11:	
12:    // short-Wert nach String
13:    // Konvertierung in einen 'Binaerstring' (Basis 2)
14:    std::string out = std::format("{:#B}, ", sVal);
15:    // long-Wert nach String
16:    out += std::format("{}\n", lVal);
17:    // float-Wert nach String
18:    out += std::format("{:.2f}\n", fVal);
19:    // String ausgeben
20:    std::cout << out;
21:	}

0B1010101, 2345000
123.46

Alternativ kann für die Konvertierung von Werten in einen String noch der Stream ostringstream verwendet werden. Da er aber keine zusätzliche Funktionalität gegenüber std::format() bietet, wird er nicht weiter betrachtet.

String zerlegen

Um einen String in einzelne Wörter zu zerlegen, kann der erwähnte Stream istringstream verwendet werden. Nachdem dem istringstream-Objekt ein String zugewiesen wurde, wird so lange aus dem istringstream ausgelesen, bis dessen Methode eof() true zurückliefert. Die einzelnen ausgelesenen Wörter werden dabei nacheinander mittels des Operators >> in ein string-Objekt übertragen.

1:	//Header-Dateien einbinden
2:	#include <string>
3:	#include <sstream>
4:	#include <print>
5:	
6:	// main() Funktion
7:	int main()
8:	{
9:     // Stringobjekte definieren
10:    std::string line, word;
11:	
12:    // Komplette Zeile von der Standard-Eingabe einlesen
13:    std::getline(std::cin,line);
14:    // Eingabe an istringstream übergeben
15:    std::istringstream is(line);
16:    // Eingabe in einzelne Woerter zerlegen
17:    while (!is.eof())
18:    {
19:       // Einzelnes Wort aus Eingabe-String extrahieren
20:       is >> word;
21:       std::println("{}",word);
22:    }
23:	}

Mithilfe des istringstream können ebenfalls Teile eines Strings, die durch ein definiertes Trennzeichen voneinander getrennt sind, extrahiert werden. Der 'Trick' ist dabei folgender:

Die Funktion getline() wurde bisher nur zum Einlesen einer kompletten Zeile von der Standardeingabe verwendet. Doch die Funktion kann wesentlich mehr. getline() kann aus einem beliebigen Input-Stream eine komplette Zeile einlesen. D.h., die Funktion getline() kann sowohl vom Eingabestream cin wie auch vom Dateistream ifstream oder vom istringstream Stream eine Zeile einlesen.

Aber es soll ja nicht die komplette Zeile in einem String abgelegt werden, sondern nur der Teil bis zum ersten definierten Trennzeichen. Und dazu wird an getline() in einem dritten Parameter das Trennzeichen als char übergeben. Standardmäßig ist das Trennzeichen der Zeilenvorschub '\n'.

1:	// Zu untersuchender String, Trennzeichen ist hier das Komma
2:	const auto LINE = "Agathe Mueller,Gansweg 23,12345 ADorf"s;
3:	// 3 string-Objekte definieren
4:	std::string name, street, city;
5:	// String in einen istringstream übertragen
6:	std::istringstream is(LINE);
7:	// Aus istringstream einlesen mit Komma als Trennzeichen
8:	std::getline(is,name,',');
9:	// Weiter einlesen bis zum nächsten Trennzeichen
10:	std::getline(is,street,',');
11:	// Nun den Rest einlesen
12:	std::getline(is,city);

Hier folgen in der Offline-Version die Übungen.