C++-Programmierung: Strings

Aus Wikibooks
Zur Navigation springen Zur Suche springen
Symbol opinion vote.svg
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() );
Wikibooks buchseite.svg Zurück zu Arrays | One wikibook.svg Hoch zu Inhaltsverzeichnis | Wikibooks buchseite.svg Vor zu Typedef