C++-Programmierung: Strings

Aus Wikibooks
Alte Seite
Diese Seite gehört zum alten Teil des Buches und wird nicht mehr gewartet. Die Inhalte sollen in das neue Buch einfließen: C++-Programmierung/ Inhaltsverzeichnis.
Eine aktuelle Seite zum gleichen Thema ist unter C++-Programmierung/ Weitere Grundelemente/ Zeichenketten verfügbar.

Allgemein[Bearbeiten]

Man unterscheidet zwei Arten von Strings:

  1. C-Strings (char*, wchar_t*)
  2. C++-Strings (std::string, std::wstring)

Dieser Abschnitt behandelt nur die Klasse std::string der Standardbibliothek, die Ihnen bereits im Abschnitt String-Operatoren kurz begegnet ist.

In den Codebeispielen wird immer die „Einleitung“

#include <string>

vorausgesetzt. Ein string ist kein gewöhnlicher Variablentyp. Er kann aber als solcher benutzt werden, wenn obige Einleitung angegeben wird.

Finden[Bearbeiten]

Die überladene Member-Funktion find sucht nach einzelnen Zeichen, C-Strings oder C++-Strings. Das zweite Argument i bezeichnet den Index, ab dem gesucht werden soll, das eventuelle dritte Argument n beschränkt die Suche auf n Zeichen. Als Resultat liefert find die erste gefundene Position oder, falls die Suche fehlschlägt, die spezielle Konstante std::string::npos zurück.

size_type find(char a, size_type i =0)                  const;
size_type find(const string& a, size_type i =0)         const;
size_type find(const char* a, size_type i =0)           const;
size_type find(const char* a, size_type i, size_type n) const;

Dazu gibt es einige Varianten.

  • rfind() sucht rückwärts,
  • find_first_of() sucht das erste Vorkommen eines Zeichens aus a,
  • find_last_of() dasselbe rückwärts,
  • find_first_not_of() sucht das erste Vorkommen eines Zeichens, das nicht aus a ist,
  • find_last_not_of() dasselbe rückwärts.

Diese besitzen die gleichen Funktionsprototypen wie find() und sind ebenfalls const.

Der als Parameter- und Rückgabetyp verwendete size_type ist ein implementationsabhängiger ganzzahliger Datentyp.

Beispiel:

std::string a("Enemenemuh");
std::string b("muh");
std::string::size_type i = a.find(b); // sucht vorwärts ab Index 0
// i ist jetzt 7, der Index in a, wo "muh" beginnt

Anhängen[Bearbeiten]

Die folgenden Operatoren hängen an den gegebenen String *this ein einzelnes Zeichen, einen C-String oder einen C++-String an. Rückgabewert ist der geänderte String *this.

string& operator+=(char a);
string& operator+=(char* a);
string& operator+=(const string& a);

Beispiel:

std::string a("Enemene");
a += "muh";
// jetzt ist a == "Enemenemuh"

Dass sich das Anhängen auch mit dem binären Operator + bewerkstelligen lässt, wissen Sie bereits aus dem Abschnitt String-Operatoren.

Vergleichen[Bearbeiten]

Die sechs Vergleichsoperatoren stehen für Strings zur Verfügung. Der Vergleich erfolgt lexikographisch.

Einfügen[Bearbeiten]

Die Member-Funktion insert fügt an der angegebenen Position i einen C-String oder C++-String ein.

string& insert(size_type i, const string& s);
string& insert(size_type i, const char* s);

Beispiel:

std::string s("Shuttle");
s.insert(1, "pace-S");
// jetzt ist s == "Space-Shuttle"
// da "pace-S" in den String "Shuttle" an der Position 1 (also nach dem Buchstaben S) eingefügt wurde
// --> ("S pace-S huttle")

Ersetzen und Löschen[Bearbeiten]

Die Member-Funktion replace ersetzt ab der Position i die nächsten n Zeichen durch den String s.

string& replace(size_type i, size_type n, const string& s);
string& replace(size_type i, size_type n, const char* s);

Die Member-Funktion erase löscht ab der Position i die nächsten n Zeichen, d.h. ersetzt sie durch einen leeren String. Lässt man das Argument n weg, wird alles ab der Position i gelöscht.

string& erase(size_type i =0, size_type n =npos);

Beispiel:

std::string s("Freibad");
s.replace(4, 3, "schwimmer");
// s == "Freischwimmer"
s.erase(4, 9); // hier wäre s.erase(4) gleichwertig
// s == "Frei"

Umwandeln in C-Strings[Bearbeiten]

Die folgenden Member-Funktionen liefern eine Darstellung des gegebenen Strings als C-String (const char*).

const char* data() const;
const char* c_str() const;

Der Unterschied zwischen den beiden Funktionen besteht darin, daß c_str() die '\0'-Terminierung anhängt, die u.a. von den auf C-Strings operierenden Routinen des Standardheaders cstring erwartet wird.

Beispiel:

std::string dir("/home/user/");
std::string file("test.cpp");
//...
std::ifstream in( (dir+file).c_str() );