namespace cpp

C++ lernen, kennen, anwenden

Benutzer-Werkzeuge

Webseiten-Werkzeuge


kennen:include:string

<string>

Zeichenkettenklasse std::string

Die Zeichenkettenklasse std::string für char bzw. std::wstring für wchar_t setzt den Programmierer von fehlerträchtigen Routineaufgaben frei. Die Speicherverwaltung erfolgt automatisch. Die std::string-Klasse besitzt neben Konstruktoren Methoden zum Zuweisen, Anhängen, Einfügen, Löschen, Ersetzen, Suchen, Vergleichen, für Ein- und Ausgabe, Zeichenzugriff, Vertauschen, Größenabfrage und den Zugriff auf Teilzeichenketten und C-Zeichenketten. Zur Beschreibung der umfangreichen Klassenschnittstelle werden folgende Parameternamen benutzt:

std::string            s;
const std::string&     str;
const char*            ptr;
char                   c;
std::string::size_type pos, n, pos2, n2;
std::string::iterator  first, last, first2, last2;

Konstruktoren

Konstruktoren schaffen einen neuen std::string aus

std::string(str, pos=0, n=pos) str ab str[pos] mit max. n Zeichen
std::string(ptr) einer C-Zeichenkette
std::string(ptr, n) mit bis zu n Zeichen oder bis zur Ende-Null
std::string(n, c) n Zeichen c
std::string(first, last) einem Iterator-Bereich [first,last)
char* ptr = "Hello, world of strings!";
std::string s1;             // leer
std::string s2 = ptr;
std::string s3(ptr);        // Kopie
std::string s4(s2, 7);      // "world of strings!" 
std::string s5(s2, 7, 5);   // "world"
std::string s6(5, '*');     // "*****"
std::string s7(ptr, ptr+5); // "Hello"

Zuweisen

Zuweisungen mit = oder der assign()-Methode weisen einem existierenden std::string

assign(str, pos=0, n=pos) str ab str[pos] mit max. n Zeichen
assign(ptr) eine C-Zeichenkette
assign(ptr, n) mit bis zu n Zeichen oder bis zur Ende-Null
assign(n, c) n Zeichen c
assign(first, last) einem Iterator-Bereich [first,last) zu
s = ptr;
s = 'C';
s.assign(5,'*');
s.assign(ptr, ptr+5);

Anhängen

Verknüpfungen (Anhängen) können mit mit Operatoren + und += erfolgen:

s += str; // s = s + str;
s += ptr; //     s + ptr
s += c;   //     s + c

Die append()-Methoden hängen an einen existierenden string

append(str, pos=0, n=pos) str ab str[pos] mit max. n Zeichen
append(ptr) eine C-Zeichenkette
append(ptr, n) mit bis zu n Zeichen oder bis zur Ende-Null
append(n, c) n Zeichen c
append(first, last) einen Iterator-Bereich [first,last) an

Einfügen

Einfügungen schieben vor pos bzw. vor den Iterator iter_pos

insert(pos, str, pos2=0, n=npos) str ab str[pos2] mit max. n Zeichen
insert(pos, ptr) eine C-Zeichenkette
insert(pos, ptr, n) mit bis zu n Zeichen oder bis zur Ende-Null
insert(pos, n, c) n Zeichen c
insert(iter_pos, c, ='\0') ein Zeichen c
insert(iter_pos, n, c) n Zeichen c
insert(iter_pos, first, last) einen Iterator-Bereich [first,last) ein
s = immer;
s.insert(0, "Mann-o-mann", 0, 3);
s.insert(3,1,' ');
s.insert(s.end(), " noch was ");
cout << s.insert(s.size(), "einfuegen.") << endl;

Löschen

Löschmethoden entfernen

erase(pos=0, n=pos) ab s[pos] maximal n Zeichen
erase(iter_pos) das Zeichen *iter_pos
erase(first, last) den Iterator-Bereich [first,last)
s = "Alles Überflüssige wird unverzüglich gelöscht.";
s.erase(s.end()-1);              // Satzpunkt weg  
s.erase(s.begin()+6, s.end()-9); // "Alles  gelöscht";
s.erase(5,2);                    // "Allesgelöscht";  

Ersetzen

Ersetzen lassen sich n Zeichen ab pos oder der Iteratorbereich (first,last) durch

replace(pos, n, str, pos2=0, n2=npos) str ab str[pos2] mit max. n2 Zeichen
replace(pos, n, ptr) eine C-Zeichenkette
replace(pos, n, ptr, n2) mit bis zu n2 Zeichen oder bis zur Ende-Null
replace(pos, n, n2, c) n2 Zeichen c
replace(first, last, str) str
replace(first, last, ptr) eine C-Zeichenkette
replace(first, last, ptr, n2) mit bis zu n2 Zeichen oder bis zur Ende-Null
replace(first, last, n2, c) n2 Zeichen c
replace(first, last, first2, last2) den Iterator-Bereich [first2,last2)
std::string s1 = "Das funktioniert nur dann, wenn du fest dran glaubst.";
std::string s2 = "nicht";
s1.replace(s1.find("nur dann"), 8, s2);    // wird länger
s1.replace(s1.find("fest"), 4, s2);        // wird kürzer  
s1.replace(s1.end()-1, s1.end(), 10, '.'); 

Suchen

Suchmethoden suchen ab s[pos] in den folgenden maximal n Zeichen einen Teilstring, eine C-Zeichenkette oder ein Zeichen

von vorn von hinten
find(str, pos=0) rfind(str, pos=npos)
find(ptr, pos, n) rfind(ptr, pos, n)
find(ptr, pos=0) rfind(ptr, pos=npos)
find(c, pos=0) rfind(c, pos=npos)
die erste Übereinstimmung die letzte Übereinstimmung
find_first_of(str, pos=0) find_last_of(str, pos=npos)
find_first_of(ptr, pos, n) find_last_of(ptr, pos, n)
find_first_of(ptr, pos=0) find_last_of(ptr, pos=npos)
find_first_of(c, pos=0) find_last_of(c, pos=npos)
die erste Nichtübereinstimmung die letzte Nichtübereinstimmung
find_first_not_of(str, pos=0) find_last_not_of(str, pos=npos)
find_first_not_of(ptr, pos, n) find_last_not_of(ptr, pos, n)
find_first_not_of(ptr, pos=0) find_last_not_of(ptr, pos=npos)
find_first_not_of(c, pos=0) find_last_not_of(c, pos=npos)

Sie liefern den Anfangsindex der gefundenen Kette bzw. des Zeichens, auf das die geforderte Bedingung zutrifft. Bei fehlgeschlagener Suche wird die Konstante std::string::npos geliefert.

std::string s = "Entente cordial";
std::string NT = "nt";
std::string vokale = "AEIOUaeiou";
 
pos = s.find(NT);                  // 1
pos = s.rfind(NT);                 // 4
pos = s.find_first_of(vokale);     // 3
pos = s.find_last_of (vokale);     // 13
pos = s.find_first_not_of(vokale); // 1
pos = s.find_last_not_of (vokale); // 14
 
if (pos != std::string::npos)
{
  std::cout << "letzter Konsonant: " << s[pos] << '\n'
            << s << '\n'
            << std::string(pos, ' ') << "^\n";
}

Vergleichen

Vergleiche mit den Operatoren == != < ⇐ >= > sind auch mit C-Zeichenketten möglich.

std::string s = "Asterix";
char*     ptr = "Obelix";
 
if (name == s || name == ptr)
{
  std::cout << "Die spinnen, die Roemer!\n";
}

Die compare()-Methoden vergleichen in s bzw. ab s[pos] maximal n Zeichen mit

compare(str, pos2=0, n2) str[pos2] bis max. str[pos2+n2]
compare(pos, n, str, pos2=0, n2=npos)
compare(ptr, n2) der C-Zeichenkette
compare(pos, n, ptr, n2=npos)

Sie liefern

  • einen negativen Wert, wenn s lexikographisch vor dem Argument kommt,
  • einen positiven Wert, wenn s danach kommt oder
  • 0 bei Übereinstimmung.

Ein- und Ausgabe

Ein- und Ausgaben erfolgen mit den Stromoperatoren. Eingelesen wird nur ein Wort bis vor das nächste Whitespace-Zeichen, führende Whitespaces werden dabei übergangen. Die globale Funktion getline() liest dagegen eine ganze Zeile, genauer alle Zeichen bis zum Auftreten des Begrenzers delim ein. Der Begrenzer wird aus dem Strom entfernt, jedoch nicht in die Zeichenkette aufgenommen.

std::cin >> s;
std::getline(std::cin, s, '\n');
std::cout << s << '\n';

Zeichenzugriff

Der Zugriff auf einzelne Zeichen erfolgt mit s[pos] ungeprüft bzw. s.at(pos) geprüft. Wenn pos hinter dem Ende liegt, wirft at() eine out_of_range-Ausnahme. Die std::string-Objekte können als sequentielle Zeichen-Container aufgefasst und mit Algorithmen bearbeitet werden.

reverse(s.begin(), s.end());

Iteratoren auf den Anfang und hinter das Ende der Zeichenfolge liefern die Methoden

begin() end() vorwärts laufend
rbegin() rend() rückwärts laufend

Vertauschen

Vertauschungen wechseln die Objektwerte aus.

std::string s1="abc", s2 = "def";
s1.swap(s2);  // (effizienter) hin
std::swap(s1, s2); // und zurück

Größe und Kapazität sind erfragbar und änderbar.

empty() liefert true bei Leerstring
length() Anzahl Zeichen
size() dto.
max_size() größtmögliche Zeichenzahl
capacity() Fassungsvermögen ohne Reallokation
reserve(n=0) reserviert Speicher für n Zeichen
resize(n, c='\0') kürzt oder füllt mit c auf
clear() leert den Inhalt

Teilketten und C-Zeichenketten

Teilzeichenketten und C-Zeichenketten lassen sich herausziehen:

substr(pos=0,n=npos) liefert maximal n Zeichen ab s[pos]
c_str() liefert temporär gültigen Zeiger auf Zeichenkette
copy(ptr, n, pos=0) kopiert maximal n Zeichen ab s[pos] nach ptr
std::string s  = "Heiliger Apollo!";
cout << s.substr(9,5) << endl; // "Apoll"

Die Umwandlung in eine C-Zeichenkette sollte nur erfolgen, wenn dies unumgänglich ist. Der von c_str() gelieferte Zeiger ist nur solange gültig, wie der liefernde string existiert und dessen Inhalt nicht geändert wurde. Die Methode wurde hauptsächlich eingeführt, weil viele (alte) Bibliotheksfunktionen einen const char* erwarten. Bei copy() muss das Feld ptr[] genügend lang sein, von copy() wird keine Ende-Null geschrieben.

char ptr[80];
std::string::size_type anzahl = s.copy(ptr, 79); // Zahl kopierter Zeichen
ptr[anzahl] = '\0';                              // manuell anfügen!

Funktionen

std::istream& getline (std::istream& in, std::string& s, char begrenzer = '\n'); 

Beschreibung: Liest aus dem Datenstrom die Zeichenfolge bis vor den begrenzer. Der Begrenzer wird aus dem Datenstrom entfernt.

std::string to_string (long long zahl); 
std::string to_string (unsigned long long zahl); 
std::string to_string (double zahl); 

Beschreibung: Konvertiert Zahl in Zeichenkette.

int                stoi   (const std::string& s, size_t *pos = 0, int base = 10);
long               stol   (const std::string& s, size_t *pos = 0, int base = 10);
long long          stoll  (const std::string& s, size_t *pos = 0, int base = 10);
unsigned long      stoul  (const std::string& s, size_t *pos = 0, int base = 10);
unsigned long long stoull (const std::string& s, size_t *pos = 0, int base = 10);

Beschreibung: Konvertiert Zeichenkette in Ganzzahl.

float       stof  (const std::string& s, size_t *pos = 0);
double      stod  (const std::string& s, size_t *pos = 0);
long double stold (const std::string& s, size_t *pos = 0);

Beschreibung: Konvertiert Zeichenkette in Gleitkommazahl.

Für MinGW 4.7.x ist ein inoffizieller Patch zur Nutzung der string-Konversionen verfügbar.

kennen/include/string.txt · Zuletzt geändert: 2013-03-17 11:14 (Externe Bearbeitung)