Klasse und Objekte
Eine Klasse ist ein Satz von Variablen und Funktionen, die zusammenarbeiten; wobei den Variablen keine Werte zugewiesen sind. Wenn den Variablen Werte zugewiesen werden, wird die Klasse zu einem Objekt. Unterschiedliche Werte für dieselbe Klasse führen zu unterschiedlichen Objekten; das heißt, verschiedene Objekte sind dieselbe Klasse mit unterschiedlichen Werten. Das Erstellen eines Objekts aus einer Klasse wird als Instanziieren des Objekts bezeichnet.
Der Name, string, ist eine Klasse. Ein aus der String-Klasse erstelltes Objekt hat einen vom Programmierer gewählten Namen.
Eine zur Klasse gehörende Funktion wird benötigt, um ein Objekt aus der Klasse zu instanziieren. In C++ hat diese Funktion denselben Namen wie der Name der Klasse. Von der Klasse erstellte (instanziierte) Objekte haben vom Programmierer unterschiedliche Namen.
Ein Objekt aus einer Klasse zu erstellen bedeutet, das Objekt zu konstruieren; es bedeutet auch Instanziieren.
Ein C++-Programm, das die String-Klasse verwendet, beginnt mit den folgenden Zeilen am Anfang der Datei:
#enthalten#enthalten
mit namespace std;
Die erste Zeile ist für die Eingabe/Ausgabe. Die zweite Zeile besteht darin, dem Programm zu ermöglichen, alle Funktionen der String-Klasse zu verwenden. Die dritte Zeile ermöglicht es dem Programm, die Namen im Standardnamensraum zu verwenden.
Überladen einer Funktion
Wenn zwei oder mehr verschiedene Funktionssignaturen denselben Namen haben, wird dieser Name als überladen bezeichnet. Wenn eine Funktion aufgerufen wird, bestimmen die Anzahl und Art der Argumente, welche Funktion ausgeführt wird.
Konstruktion
Zeichenfolge()
Die folgende Anweisung erstellt eine Zeichenfolge der Länge Null ohne Zeichen.
Es beginnt mit dem Namen der Klasse (Objekttyp), string. Darauf folgt der vom Programmierer vergebene Name für den Objektstring. Der Zuweisungsoperator folgt; dann der Name des Konstruktors mit leeren Klammern. strCol ist hier das instanziierte Objekt mit allen Datenmembern (Eigenschaften) und Memberfunktionen (Methoden).
Zeichenfolge(str)
Dies ähnelt dem obigen, nimmt jedoch im Konstruktor entweder ein Zeichenfolgenliteral oder einen Bezeichner als Argument an. Die folgende Aussage veranschaulicht dies:
Konstruktion mit Initialisiererliste
Der folgende Code veranschaulicht dies:
string strCol=Schnur({'ICH','','das','oder','v','Und','','und','oder','du',' 0'});Das String-Literal ist Ich liebe dich. Beachten Sie das Null-Zeichen am Ende der Initialisierungsliste.
string(str, n)
Dies bildet eine String-Sammlung der ersten n Zeichen eines anderen Strings. Der folgende Code veranschaulicht dies:
verkohlenP[] = 'Ich liebe dich';string strCol=Schnur(P, 6);
Kosten<<strCol<< ' ';
Die Ausgabe ist I love mit den ersten 6 Zeichen von I love you. Denken Sie daran: Das einzelne Leerzeichen ist ein Zeichen.
string(str, pos, n)
Dies bildet eine Zeichenfolgensammlung von n Zeichen, beginnend mit der nullbasierten indizierten Position pos einer anderen Zeichenfolge. Der folgende Code veranschaulicht dies:
verkohlenP[] = 'Ich liebe dich';string strCol=Schnur(P, 2, 4);
Kosten<<strCol<< ' ';
Die Ausgabe ist, Liebe.
In den beiden oben genannten Fällen wird, wenn n größer als die Größe des Strings ist, die out_of_range-Ausnahme ausgelöst – siehe später.
string(n, 'c')
Bildet eine Sammlung von n Zeichen, wobei alle Zeichen gleich sind. Erwägen,
string strCol=Schnur(5,'Und');Kosten<<strCol<< ' ';
Die Ausgabe ist, eeeee, 5 e.
Zuweisen einer Zeichenfolge
Ein String kann wie folgt zugewiesen werden, nachdem beide Strings deklariert wurden:
Zeichenfolge strCol1=Schnur('Ich liebe dich');Zeichenfolge strCol2;
strCol2=strCol1;
Kosten<<strCol2<< ' ';
Die Ausgabe ist, ich liebe dich.
Konstruieren mit Iterator
Ein Iterator bietet eine generische Darstellung des Scannens durch die Werte einer Sammlung. Eine Syntax zum Erstellen einer Zeichenfolge mit Iterator lautet:
Vorlage<Klasse InputIterator>basic_string(InputIterator beginnen,InputIterator-Ende, constZuteiler&
zu=Zuteiler());
Dies konstruiert einen String für den Bereich [begin, end) – siehe Details später.
Einen String zerstören
Um eine Zeichenfolge zu zerstören, lassen Sie sie einfach aus dem Geltungsbereich.
Zugriff auf Zeichenfolgenklassenelemente
Ein instanziiertes String-Objekt kann wie ein Array mit einem Index versehen (indiziert) werden. Die Indexzählung beginnt bei Null.
stringName[i]
Die Operation stringName[i] liefert eine Referenz auf das Zeichen (Element) am iNSIndex der Zeichensammlung. Der folgende Code gibt v aus:
string strCol=Schnur('Ich liebe dich');verkohlenCH=strCol[4];
Kosten<<CH<< ' ';
stringName[i] const
Die Operation stringName[i] const wird anstelle von stringName[i] ausgeführt, wenn das String-Objekt ein konstantes Objekt ist. Es wird beispielsweise im folgenden Code verwendet:
conststring strCol=Schnur('Ich liebe dich');verkohlenCH=strCol[4];
Kosten<<CH<< ' ';
Der Ausdruck gibt eine konstante Referenz auf das i . zurückNSElement des String-Objekts. Keines der Elemente der Zeichenfolge kann geändert werden.
Zuweisen eines Zeichens mit tiefgestelltem Index
Ein Zeichen kann einem nicht konstanten String-Objekt wie folgt zugewiesen werden:
string strCol=Schnur('Ich rufe');strCol[2] = 'F';
Kosten<<strCol<< ' ';
Die Ausgabe ist ich falle. „c“ wurde in „f“ geändert.
stringName.at(i)
stringName.at(i) ähnelt stringName[i], aber stringName.at(i) ist zuverlässiger. Der folgende Code zeigt, wie er verwendet werden sollte:
string strCol=Schnur('Ich liebe dich');verkohlenCH=strSpal.bei(4);
Kosten<<CH<< ' ';
at() ist eigentlich eine String-Klassen-Memberfunktion.
stringName.at(i) const
stringName.at(i) const ist ähnlich zu stringName[i] const, aber stringName.at(i) const ist zuverlässiger. stringName.at(i) const wird anstelle von stringName.at(i) ausgeführt, wenn das String-Objekt ein konstantes String-Objekt ist. Es wird beispielsweise im folgenden Code verwendet:
conststring strCol=Schnur('Ich liebe dich');verkohlenCH=strSpal.bei(4);
Kosten<<CH<< ' ';
at() const ist eigentlich eine String-Klassenmemberfunktion.
Zuweisen eines Wertes mit der at()-Funktion
Einem nicht konstanten String-Objekt kann mit der Funktion at() wie folgt ein Wert zugewiesen werden:
string strCol=Schnur('Ich rufe');strSpal.bei(2) = 'F';
Kosten<<strCol<< ' ';
Die Ausgabe ist ich falle.
Problem mit Subskription
Das Problem bei der Subskription (Indexierung) besteht darin, dass, wenn der Index außerhalb des zulässigen Bereichs liegt, möglicherweise ein falsches Ergebnis erzielt wird oder zur Laufzeit ein Fehler ausgegeben wird.
Vorderseite()
Dies gibt einen Verweis auf das erste Element des String-Objekts zurück, ohne das Element zu entfernen. Die Ausgabe des folgenden Codes ist „I“.
string strCol=Schnur('Ich liebe dich');verkohlenCH=strSpal.Vorderseite();
Kosten<<CH<< ' ';
Das Zeichen wird nicht aus dem String-Objekt entfernt.
front() const
Wenn der String-Objektkonstruktion const vorangestellt ist, wird der Ausdruck front() const anstelle von front() ausgeführt. Es wird beispielsweise im folgenden Code verwendet.
conststring strCol=Schnur('Ich liebe dich');verkohlenCH=strSpal.Vorderseite();
Kosten<<CH<< ' ';
Es wird ein konstanter Verweis zurückgegeben. Das Element wird nicht aus dem String-Objekt entfernt. Für ein konstantes String-Objekt kann kein Zeichen geändert werden.
zurück()
Dies gibt eine Referenz auf das letzte Element des String-Objekts zurück, ohne das Element zu entfernen. Die Ausgabe des folgenden Codes ist ‚u‘.
string strCol=Schnur('Ich liebe dich');verkohlenCH=strSpal.zurück();
Kosten<<CH<< ' ';
zurück() const
Wenn der Konstruktion des String-Objekts const vorangestellt ist, wird der Ausdruck back() const anstelle von back() ausgeführt. Es wird beispielsweise im folgenden Code verwendet.
conststring strCol=Schnur('Ich liebe dich');verkohlenCH=strSpal.zurück();
Kosten<<CH<< ' ';
Es wird ein konstanter Verweis zurückgegeben. Das Element wird nicht aus dem String-Objekt entfernt.
Saitenkapazität
size_type capacity() const noexcept
Die Gesamtzahl der Zeichen, die die Zeichenfolge enthalten kann, ohne dass eine Neuzuweisung erforderlich ist, wird von dieser Kapazitätsmemberfunktion zurückgegeben. Ein Codesegment hierfür ist:
string strCol=Schnur();intAuf eins=strSpal.Kapazität();
Kosten<<Auf eins<< ' ';
Die Ausgabe ist 15 auf meinem Computer.
Reserve(n)
Speicherplatz ist im freien Speicher nicht immer verfügbar. Zusätzliche Plätze können im Voraus reserviert werden. Betrachten Sie das folgende Codesegment:
string strCol=Schnur('Liebe');strSpal.Reservieren(6);
Kosten<<strSpal.Kapazität() << ' ';
Die Ausgabe ist 15 auf meinem Computer.
size() const keine Ausnahme
Dies gibt die Anzahl der Zeichen in der Zeichenfolge zurück. Der folgende Code veranschaulicht:
string strCol=Schnur('Ich liebe dich');intAuf eins=strSpal.Größe();
Kosten<<Auf eins<< ' ';
Die Ausgabe ist 10, die das Zeichen null, nicht enthält.
Länge() const keine Ausnahme
-gleich wie größe().Notiz:Größe() <=Kapazität().
schrumpfen bis es passt()
Kann capacity() auf size() reduzieren, indem eine Neuzuweisung verursacht wird; es ist nicht obligatorisch. Der folgende Code demonstriert dies:
string strCol=Schnur('Ich liebe dich');strSpal.Reservieren(12);
strSpal.schrumpfen bis es passt();
intS=strSpal.Größe();
Kosten<<S<< ' ';
Die Ausgabe ist 10 und nicht 12 oder 16. Die Funktion gibt void zurück.
Größe ändern (Größe), Größe ändern (Größe,’c’)
Dadurch wird die Zeichenfolge skaliert. Ist die neue Größe kleiner als die alte Größe, werden die Elemente gegen Ende gelöscht. Wenn die neue Größe länger ist, wird gegen Ende ein Standardzeichen hinzugefügt. Um ein bestimmtes Zeichen hinzuzufügen, verwenden Sie die Funktion resize() mit zwei Argumenten. Das folgende Codesegment veranschaulicht die Verwendung der beiden Funktionen:
string strCol=Schnur('Ich liebe dich');strSpal.Größe ändern(6);
Kosten<< 'Neue Größe von strCol: ' <<strSpal.Größe() << ' ';
Zeichenfolge strCol1=Schnur('Ich liebe', 'Und');
strSpal1.Größe ändern(12);
Kosten<< 'Neue Größe von strCol1: ' <<strSpal1.Größe() << ' ';
Die Ausgabe ist:
Neue Größe von strCol: 6Neue Größe von strCol1: 12
Die Funktion gibt void zurück.
clear() keine Ausnahme
Entfernt alle Elemente aus der Zeichenfolge, wie das folgende Codesegment veranschaulicht:
string strCol=Schnur('Ich liebe dich');strSpal.klar();
Kosten<<strSpal.Größe() << ' ';
Die Ausgabe ist 0. Die Funktion gibt void zurück.
empty() const noexcept
Dies gibt 1 für wahr zurück, wenn das Zeichenfolgenobjekt kein Zeichen enthält, oder 0 für falsch, wenn das Zeichenfolgenobjekt nicht leer ist. Der folgende Code veranschaulicht dies:
Zeichenfolge strCol1=Schnur('Ich liebe dich');Kosten<<strSpal1.leer() << ' ';
Zeichenfolge strCol2=Schnur();
Kosten<<strCol2.leer() << ' ';
Die Ausgabe ist:
01
Zurückgeben von Iteratoren und der String-Klasse
Ein Iterator ist wie ein Zeiger, hat aber mehr Funktionalität als der Zeiger.
begin() keine Ausnahme
Gibt einen Iterator zurück, der auf das erste Zeichen (Element) des String-Objekts zeigt, wie im folgenden Codesegment:
string strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::Iteratoriter=strSpal.Start();
Kosten<< *iter<< ' ';
Die Ausgabe ist „Ich“. Beachten Sie, wie die Deklaration, die den Iterator empfängt, deklariert wurde. Der Iterator wird in einem Rückgabeausdruck dereferenziert, um den Wert zu erhalten, genauso wie ein Zeiger dereferenziert wird.
begin() const noexcept;
Gibt einen Iterator zurück, der auf das erste Element der String-Objektauflistung zeigt. Wenn der Objektkonstruktion const vorangestellt ist, wird der Ausdruck begin() const anstelle von begin() ausgeführt. Unter dieser Bedingung kann das entsprechende Element im Objekt nicht geändert werden. Es wird beispielsweise im folgenden Code verwendet.
conststring strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::const_iteratoriter=strSpal.Start();
Kosten<< *iter<< ' ';
Die Ausgabe ist „Ich“. Beachten Sie, dass diesmal const_iterator anstelle von nur iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.
end() keine Ausnahme
Gibt einen Iterator zurück, der direkt über das letzte Element des Zeichenfolgenobjekts hinaus zeigt. Betrachten Sie das folgende Codesegment:
string strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::Iteratoriter=strSpal.Ende();
Kosten<< *iter<< ' ';
Die Ausgabe ist null, was nichts ist, da es über das letzte Element hinaus kein konkretes Element gibt.
end() const noexcept
Gibt einen Iterator zurück, der direkt über das letzte Element des Zeichenfolgenobjekts hinaus zeigt. Wenn der Konstruktion des String-Objekts const vorangestellt ist, wird der Ausdruck end() const anstelle von end() ausgeführt. Betrachten Sie das folgende Codesegment:
conststring strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::const_iteratoriter=strSpal.Ende();
Kosten<< *iter<< ' ';
Die Ausgabe ist null. Beachten Sie, dass diesmal const_iterator anstelle von nur iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.
Umgekehrte Iteration
Es ist möglich, einen Iterator zu haben, der vom tatsächlichen Ende bis kurz vor dem ersten Element iteriert:
rbegin() keine Ausnahme
Gibt einen Iterator zurück, der auf das letzte Element des string-instanziierten Objekts zeigt, wie im folgenden Codesegment:
string strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::reverse_iteratoriter=strSpal.rbegin();
Kosten<< *iter<< ' ';
Die Ausgabe ist „u“. Beachten Sie, wie die Deklaration, die den umgekehrten Iterator empfängt, deklariert wurde. Der Iterator wird in einem Rückgabeausdruck dereferenziert, um den Wert zu erhalten, genauso wie ein Zeiger dereferenziert wird.
rbegin() const noaußer;
Gibt einen Iterator zurück, der auf das letzte Element des String-Objekts zeigt. Wenn der Objektkonstruktion const vorangestellt ist, wird der Ausdruck rbegin() const anstelle von rbegin() ausgeführt. Unter dieser Bedingung kann das entsprechende Element im Objekt nicht geändert werden. Die Funktion wird beispielsweise im folgenden Code verwendet.
conststring strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::const_reverse_iteratoriter=strSpal.rbegin();
Kosten<< *iter<< ' ';
Die Ausgabe ist „u“. Beachten Sie, dass diesmal const_reverse_iterator anstelle von reverse_iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.
render () keine Ausnahme
Gibt einen Iterator zurück, der direkt vor dem ersten Element des String-Objekts zeigt. Betrachten Sie das folgende Codesegment:
string strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::reverse_iteratoriter=strSpal.macht();
Kosten<< *iter<< ' ';
Die Ausgabe ist null, was nichts ist, da direkt vor dem ersten Element kein konkretes Element vorhanden ist.
render () const noexcept
Gibt einen Iterator zurück, der direkt vor dem ersten Element des String-Objekts zeigt. Wenn der Objektkonstruktion const vorangestellt ist, wird der Ausdruck rend() const anstelle von rend() ausgeführt. Betrachten Sie das folgende Codesegment:
conststring strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::const_reverse_iteratoriter=strSpal.macht();
Kosten<< *iter<< ' ';
Die Ausgabe ist null. Beachten Sie, dass diesmal const_reverse_iterator anstelle von reverse_iterator verwendet wurde, um den zurückgegebenen Iterator zu erhalten.
String-Modifikatoren
Ein Modifikator, der das String-Objekt modifiziert, kann auch einen Iterator annehmen oder zurückgeben.
Anhängen
basic_string&Operator+ =(constbasic_string&P)Hängt das rechte String-Objekt an das linke String-Objekt an. Beispiel:
Zeichenfolge strCol1=Schnur('Ich liebe');Zeichenfolge strCol2=Schnur(' Sie');
strCol1+ =strCol2;
Kosten<<strCol1<< ' ';
Die Ausgabe ist Ich liebe dich. Vergessen Sie nicht, dass strCol1 += strCol2 gleich strCol1 = strCol1+strCol2 ist.
basic_string& operator+=(const charT* s)
Fügt ein Zeichenfolgenliteral an eine Zeichenfolgenobjektauflistung an. Beispiel:
string strCol=Schnur('Ich liebe');strCol+ = ' Sie';
Kosten<<strCol<< ' ';
Ausgabe: Ich liebe dich.
basic_string& Operator+=(charT c)
Hängt ein einzelnes Zeichen an eine Objektzeichenfolge an. Beispiel:
string strCol=Schnur('Ich liebe dich');strCol+ = 'du';
Kosten<<strCol<< ' ';
Ausgabe: Ich liebe dich.
basic_string& operator+=(initializer_list)
Fügt eine Initialisierungsliste an. Beispiel:
string strCol=Schnur('Ich liebe');strCol+ = {'','und','oder','du',' 0'};
Kosten<<strCol<< ' ';
Ausgabe: Ich liebe dich. Es ist immer gut, die Null, , am Ende einer Zeicheninitialisiererliste hinzuzufügen.
basic_string& append(const basic_string& str)
Hängt das Argument-String-Objekt an das Haupt-String-Objekt an. Beispiel:
Zeichenfolge strCol1=Schnur('Ich liebe');Zeichenfolge strCol2=Schnur(' Sie');
strSpal1.anhängen(strCol2);
Kosten<<strCol1<< ' ';
Ausgabe: Ich liebe dich.
basic_string& append(const charT* s)
Fügt ein Zeichenfolgenliteralargument an die Hauptzeichenfolge an. Beispiel
string strCol=Schnur('Ich liebe');strCol=strSpal.anhängen(' Sie');
Kosten<<strCol<< ' ';
Ausgabe: Ich liebe dich.
basic_string& append(initializer_list)
Hängt die Initialisierungsliste, die ein Argument ist, an die Hauptzeichenfolge an. Beispiel:
string strCol=Schnur('Ich liebe');strCol=strSpal.anhängen({'','und','oder','du',' 0'});
Kosten<<strCol<< ' ';
Ausgabe: Ich liebe dich. Es ist immer gut, das Zeichen null, am Ende einer Initialisierungsliste hinzuzufügen.
basic_string& append(size_type n, charT c)
Fügt n des gleichen Zeichens an. Beispiel:
string strCol=Schnur('Tab');strCol=strSpal.anhängen(2, 'oder');
Kosten<<strCol<< ' ';
Ausgabe: Tabu.
basic_string& append(const charT* s, size_type n)
Hängt die ersten n Elemente eines Zeichenfolgenliterals an das Hauptzeichenfolgenobjekt an. Beispiel:
string strCol=Schnur('Ich liebe');strCol=strSpal.anhängen('du so', 4);
Kosten<<strCol<< ' ';
Die Ausgabe ist: Ich liebe dich. Wenn n größer als die Länge des Literals ist, wird eine length_error-Ausnahme ausgelöst.
basic_string& append(const basic_string& str, size_type pos, size_type n = npos)
Fügt n Zeichen aus dem Index pos an den Hauptstring an. Beispiel:
string strCol=Schnur('Ich liebe');strCol=strSpal.anhängen(hast du so, 2, 4);
Kosten<<strCol<< ' ';
Ausgabe: Ich liebe dich. Auch hier würde eine Ausnahme geworfen, siehe später.
Zuweisen
basic_string&zuordnen(constbasic_string&P)Weist das Argument-String-Objekt dem Haupt-String zu und ersetzt alle dort vorhandenen Inhalte.
Zeichenfolge strCol1=Schnur('Ich liebe dich');Zeichenfolge strCol2=Schnur('Sie braucht mich');
strCol1=strSpal1.zuordnen(strCol2);
Kosten<<strCol1<< ' ';
Ausgabe: Sie braucht mich.
basic_string&zuordnen(constDiagramm*S)Weist der Hauptzeichenfolge ein Zeichenfolgenliteralargument zu, das alle vorhandenen Inhalte ersetzt.
string strCol=Schnur('Ich liebe dich');strCol=strSpal.zuordnen('Sie braucht mich');
Kosten<<strCol<< ' ';
Ausgabe: Sie braucht mich.
basic_string&zuordnen(initializer_list<Diagramm>)Weist dem Hauptstring ein Initialisierungslistenargument zu,Ersetzen Sie alle vorhandenen Inhalte.
[cc lang='C'entkam='wahr'Breite='780']
string strCol=Schnur('Ich liebe dich');
strCol=strSpal.zuordnen({'S','h','Und','','n','Und','Und','D','S','','m','Und',' 0'});
Kosten<<strCol<< ' ';
Ausgabe: Sie braucht mich. Es ist gut, immer die Null, , am Ende der Zeichenliste hinzuzufügen, um ein String-Literal zu bilden.
basic_string&zuordnen(constDiagramm*S,size_type n)Weist die ersten n Zeichen eines String-Literalarguments dem Hauptstring zu und ersetzt jeglichen dort vorhandenen Inhalt.
string strCol=Schnur('Ich liebe dich');strCol=strSpal.zuordnen('Sie braucht mich', 9);
Kosten<<strCol<< ' ';
Ausgabe: Sie braucht.
basic_string&zuordnen(size_type n,diagramm c)Weist der Hauptzeichenfolge ein Argument von n derselben Zeichen zu und ersetzt alle vorhandenen Inhalte.
string strCol=Schnur('Ich liebe dich');strCol=strSpal.zuordnen(4, 'Und');
Kosten<<strCol<< ' ';
Ausgabe: eeee
basic_string&zuordnen(constbasic_string&P,Größe_Typ Pos,size_type n=npos)
Weist n Zeichen eines String-Objektarguments, beginnend bei pos, dem Hauptstring zu und ersetzt jeglichen dort vorhandenen Inhalt.
string strCol=Schnur('Ich liebe dich');strCol=strSpal.zuordnen('Sie braucht mich', 4, 5);
Kosten<<strCol<< ' ';
Ausgabe: Bedarf. Würde eine Ausnahme auslösen – siehe später.
Einfügen
basic_string&Einfügung(Größe_Typ Pos, constbasic_string&P)Fügt das String-Objektargument in den Hauptstring ein, bei index, pos.
Zeichenfolge strCol1=Schnur('Ich liebe dich');Zeichenfolge strCol2=Schnur('Hass und');
strCol1=strSpal1.Einfügung(2,strCol2);
Kosten<<strCol1<< ' ';
Ausgabe: Ich hasse und liebe dich. Würde eine Ausnahme auslösen – siehe später.
basic_string&Einfügung(size_type pos1, constbasic_string&P,size_type pos2,size_type n=npos)
Fügt eine Länge von n Zeichen von pos2 des Zeichenfolgenobjektarguments in die Hauptzeichenfolge bei Index pos1 ein.
Zeichenfolge strCol1=Schnur('Ich liebe dich');Zeichenfolge strCol2=Schnur('Hass, wollen und brauchen');
strCol1=strSpal1.Einfügung(2,strCol2, 6, 9);
Kosten<<strCol1<< ' ';
Ausgabe: Ich will und liebe dich.
iterator insert(const_iterator p, charT c)
Fügt ein bestimmtes Zeichen, das ein Argument ist, an der Position ein, auf die der Iterator zeigt. Gibt einen Iterator für die Position des neu eingefügten Zeichens zurück.
string strCol=Schnur('Ich liebe dich');basic_string<verkohlen> ::Iteratoriter=strSpal.Start();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<verkohlen> ::IteratorNetzwerk=strSpal.Einfügung(iter, 'D');
Kosten<< *Netzwerk<< ' ';
Kosten<<strCol<< ' ';
Die Ausgabe ist:
'D'
ich habe dich geliebt
iterator insert(const_iterator p, size_type n, charT c)
Fügt n mit dem gleichen Zeichen des Arguments an der Position ein, auf die der Iterator zeigt. Gibt einen Iterator für die Position des Anfangs der neu eingefügten gleichen Zeichen zurück.
string strCol=Schnur('Tab im Land.');basic_string<verkohlen> ::Iteratoriter=strSpal.Start();
++iter; ++iter; ++iter;
basic_string<verkohlen> ::IteratorNetzwerk=strSpal.Einfügung(iter, 2, 'oder');
Kosten<< *Netzwerk<< ' ';
Kosten<<strCol<< ' ';
Die Ausgabe ist:
'oder'
Tabu im Land.
basic_string&Einfügung(Größe_Typ Pos, constDiagramm*S)Fügt ein Argument-String-Literal am Index, pos in den Haupt-String ein.
string strCol=Schnur('Tab im Land.');strCol=strSpal.Einfügung(3, 'oo');
Kosten<<strCol<< ' ';
Ausgabe: Tabu im Land.
basic_string&Einfügung(Größe_Typ Pos, constDiagramm*S,size_type n)Fügt die ersten n Zeichen des Argumentstringliterals am Index pos in den Hauptstring ein.
string strCol=Schnur('Tab im Land.');strCol=strSpal.Einfügung(3, 'oooo', 2);
Kosten<<strCol<< ' ';
Ausgabe: Tabu im Land.
Ersetzen
basic_string&ersetzen(size_type pos1,size_type n1, constbasic_string&P))Ersetzt n1 Zeichen im Haupt-String-Objekt aus Index, pos1, durch das Argument-String-Objekt.
Zeichenfolge strCol1=Schnur('Ich liebe dich');Zeichenfolge strCol2=Schnur('hasse dich und');
strCol1=strSpal1.ersetzen(2, 4,strCol2);
Kosten<<strCol1<< ' ';
Ausgabe: Ich hasse dich und dich. Würde eine Ausnahme auslösen – siehe später.
basic_string&ersetzen(size_type pos1,size_type n1, constbasic_string&P,size_type pos2,Größe_Typ n2=npos)
Ersetzt n1 Zeichen im Hauptstringobjekt aus dem Index pos1 durch n2 Zeichen des Argumentstringobjekts aus dem Index pos2.
Zeichenfolge strCol1=Schnur('Ich liebe dich');Zeichenfolge strCol2=Schnur(„Wir hassen ihn und sie“);
strCol1=strSpal1.ersetzen(2, 4,strCol2, 3, 12);
Kosten<<strCol1<< ' ';
Ausgabe: Ich hasse ihn und dich.
basic_string&ersetzen(size_type pos1,size_type n1, constDiagramm*S,Größe_Typ n2)
Ersetzt n1 Zeichen im Haupt-String-Objekt aus dem Index pos1 durch die ersten n2 Zeichen des Literal-String-Arguments.
Zeichenfolge strCol1=Schnur('Ich liebe dich');strCol1=strSpal1.ersetzen(2, 4, 'hasse ihn und sie', 12);
Kosten<<strCol1<< ' ';
Ausgabe: Ich hasse ihn und dich.
basic_string& replace(size_type pos, size_type n, const charT* s)
Ersetzt n Zeichen im Haupt-String-Objekt von index, pos, durch das Literal-String-Argument.
Zeichenfolge strCol1=Schnur('Ich liebe dich');strCol1=strSpal1.ersetzen(2, 4, 'hasse ihn und');
Kosten<<strCol1<< ' ';
Ausgabe: Ich hasse ihn und dich.
basic_string&ersetzen(size_type pos1,size_type n1,Größe_Typ n2,diagramm c)Ersetzt n1 Zeichen im Hauptstringobjekt aus dem Index pos1 durch n2 des gleichen Zeichens des Arguments.
Zeichenfolge strCol1=Schnur('Eine schlechte Tablette da.');strCol1=strSpal1.ersetzen(9, 3, 2, 'oder');
Kosten<<strCol1<< ' ';
Ausgabe: Ein schlechtes Tabu dort..
Iterator löschen (const_iterator p)
Entfernt ein Zeichen an der Position, auf die der Iterator zeigt; gibt dann die Iteratorposition zurück, die jetzt von dem Zeichen eingenommen wird, das neben diesem Zeichen stand (oder end()). Der folgende Code veranschaulicht dies:
string strCol=Schnur('A B C D');basic_string<verkohlen> ::Iteratoriter=strSpal.Start();
++iter; ++iter;
strSpal.löschen(iter);
Kosten<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' ';
Die Ausgabe: a b d
basic_string&löschen(Größe_Typ Pos= 0,size_type n=npos)Entfernt n Zeichen aus dem Index, Pos.
string strCol=Schnur('A B C D');strSpal.löschen(1, 2);
Kosten<<strCol[0] << '' <<strCol[1] << ' ';
Ausgabe: a d
void push_back(charT c)
So fügen Sie am Ende der Zeichenfolge ein einzelnes Zeichen hinzu:
string strCol=Schnur('A B C D');strSpal.push_back('5');
Kosten<<strCol<< ' ';
Ausgabe: abcd5
void pop_back()
Entfernt das letzte Zeichen, ohne es zurückzugeben. Die Stringgröße wird um 1 reduziert.
string strCol=Schnur('abcd');strSpal.Pop zurück();
Kosten<<strCol<< ' ';
Ausgabe: abcd
void swap(basic_string& s)
Die Literale zweier String-Objekte können vertauscht werden.
Zeichenfolge strCol1=Schnur(<Hilfe='post-69618-__DdeLink__781_3724385525'>zu>'abcd');Zeichenfolge strCol2=Schnur('1234567');
strSpal1.Tauschen(strCol2);
Kosten<<strCol1<< ' ';
Kosten<<strCol2<< ' ';
Die Ausgabe ist:
'1234567''abcd'
String-Operationen
const charT* c_str() const noexcept
Gibt einen Zeiger auf das erste Element des Strings zurück. Der Zeiger kann inkrementiert werden.
conststring strCol=Schnur('abcd');const verkohlen*P=strSpal.c_str();
Kosten<< *P<< ' ';
++P;
Kosten<< *P<< ' ';
Ausgabe ist:
zuB
Wegen der zweiten const in der Überschrift kann das Programm kein Zeichen in der Zeichenfolge ändern. Der Konstruktion geht const.
const charT* data() const noexcept
Gibt einen Zeiger auf das erste Element des Strings zurück. Der Zeiger kann inkrementiert werden.
conststring strCol=Schnur('abcd');const verkohlen*P=strSpal.Daten();
Kosten<< *P<< ' ';
++P;
Kosten<< *P<< ' ';
Ausgabe ist:
zuB
Wegen der zweiten const in der Überschrift kann das Programm kein Zeichen in der Zeichenfolge ändern. Der Konstruktion geht const.
basic_string substr(size_type pos = 0, size_type n = npos) const
Gibt ein String-Objekt mit n Zeichen für den Teilstring zurück, beginnend mit dem Index, pos.
conststring strCol=Schnur('abcdefghij');constZeichenfolge retStr=strSpal.substr(2, 4);
Kosten<<retStr<< ' ';
Ausgabe: cdef
find() Member-Funktionen
size_type find(const basic_string& str, size_type pos = 0) const noexcept
Sucht nach einem Teilzeichenfolgenobjekt beginnend mit dem Index, pos. Gibt, falls gefunden, den Anfang der Teilzeichenfolge in der Hauptzeichenfolge zurück.
string strCol=Schnur('Wir sind die Welt!');Zeichenfolge strCol1=Schnur('das');
intAuf eins=strSpal.finden(strCol1, 2);
Kosten<<Auf eins<< ' ';
Ausgabe:
Index: 7Gibt -1 zurück, wenn nicht gefunden.
size_type find(const charT* s, size_type pos = 0) const
Sucht nach einem Teilzeichenfolgenliteral beginnend mit dem Index, pos. Gibt, falls gefunden, den Anfang der Teilzeichenfolge in der Hauptzeichenfolge zurück.
string strCol=Schnur('Wir sind die Welt!');intAuf eins=strSpal.finden('sind', 0);
Kosten<<Auf eins<< ' ';
Da pos = 0 die Vorgabe ist, hätte 0 im Argument weggelassen werden können.
Ausgang: 3
Gibt -1 zurück, wenn nicht gefunden.
size_type find (const charT* s, size_type pos, size_type n) const
Sucht nach den ersten n Zeichen eines Teilstringliterals, beginnend mit dem Index, pos. Gibt, falls gefunden, den Anfang der Teilzeichenfolge in der Hauptzeichenfolge zurück.
string strCol=Schnur('Der größte Junge');intAuf eins=strSpal.finden('größer', 1, 3);
Kosten<<Auf eins<< ' ';
Ausgang: 4
Gibt -1 zurück, wenn nicht gefunden.
size_type find(charT c, size_type pos = 0) const
Sucht nach dem Zeichen c beginnend mit dem Index, pos. Gibt, falls gefunden, den Anfang der Teilzeichenfolge in der Hauptzeichenfolge zurück. Wenn nicht gefunden, wird -1 zurückgegeben.
string strCol=Schnur('Wir sind die Welt!');intAuf eins=strSpal.finden('Mit');
Kosten<<Auf eins<< ' ';
Ausgabe: -1
Die folgenden reverse find()-Memberfunktionen existieren:
size_type rfind(constbasic_string&P,Größe_Typ Pos=npos) constkeine Ausnahme;size_type rfind(constDiagramm*S,Größe_Typ Pos=npos) const;
size_type rfind(constDiagramm*S,Größe_Typ Pos,size_type n) const;
size_type rfind(diagramm c,Größe_Typ Pos=npos) const;
Vergleichselementfunktionen
int vergleichen(const basic_string& str) const noexcept
Vergleicht das Argument-String-Objekt mit dem Haupt-String-Objekt. Wenn die Hauptzeichenfolge vor dem Argument (im Wörterbuch) auftritt, wird eine positive Zahl zurückgegeben. Wenn es nach der Hauptzeichenfolge auftritt, wird eine negative Zahl zurückgegeben. Wenn die beiden Zeichenfolgen gleich sind, wird Null zurückgegeben.
Zeichenfolge strCol1=Schnur('Menge');Zeichenfolge strCol2=Schnur('Personen');
intAuf eins=strSpal1.vergleichen(strCol2);
Kosten<<Auf eins<< ' ';
Ausgang: -13
int vergleich(const charT* s) const
Wie oben, aber das Argument ist ein Zeichenfolgenliteral.
Zeichenfolge strCol1=Schnur('Personen');intAuf eins=strSpal1.vergleichen('Personen');
Kosten<<Auf eins<< ' ';
Ausgang: 0
String-Operatoren
Diese Operatoren gelten für Zeichenfolgenobjekte und nicht unbedingt für Zeichenfolgenliterale.
+
Verkettet zwei Zeichenfolgenobjekte und gibt die Verkettung zurück.
Zeichenfolge strCol1=Schnur('weiter tanzen');Zeichenfolge strCol2=Schnur(' der Mond');
string strCol=strCol1+strCol2;
Kosten<<strCol<< ' ';
Ausgabe: Tanzen auf dem Mond.
==
Gibt 1 für true zurück, wenn die String-Objekte gleich sind; und null für falsch, wenn sie es nicht sind.
Zeichenfolge strCol1=Schnur('weiter tanzen');Zeichenfolge strCol2=Schnur(' Auf dem Mond');
bool bl=strCol1==strCol2;
Kosten<<bl<< ' ';
Ausgang: 0
! =
Gibt 1 zurück, wenn die String-Objekte nicht identisch sind, und null, wenn dies der Fall ist.
Zeichenfolge strCol1=Schnur('weiter tanzen');Zeichenfolge strCol2=Schnur(' Auf dem Mond');
bool bl=strCol1! =strCol2;
Kosten<<bl<< ' ';
Ausgang: 1
<
Gibt 1 zurück, wenn der linke Operand laut Wörterbuch kleiner als der rechte Operand ist, oder null, wenn dies nicht der Fall ist.
Zeichenfolge strCol1=Schnur('weiter tanzen');Zeichenfolge strCol2=Schnur(' Auf dem Mond');
bool bl=strCol1<strCol2;
Kosten<<bl<< ' ';
Ausgang: 0
Bei gewöhnlichen Zeichen in C++ stehen in aufsteigender Reihenfolge Zahlen vor Großbuchstaben, die vor Kleinbuchstaben stehen. Das Leerzeichen kommt vor Null und allen.
C++-Hauptzeichenfolgen-Zeichentypen
verkohlen
Der Typ char ist der ursprüngliche C++-Typ und würde normalerweise ein Zeichen in 8 Bit speichern.
char16_t
Dies speichert ein Zeichen in 16 Bit.
char32_t
Dies speichert ein Zeichen in 32 Bit.
wchar_t
char16_t und char32_t sind Breitzeichen. wchar_t ist ein Breitzeichen, das proprietär und implementierungsdefiniert ist.
Diese Typen werden Eigenschaften genannt. C++ bezeichnet sie jedoch technisch als Spezialisierungen von Merkmalen. Dieser Artikel hat sich auf den Zeichentyp konzentriert. Die Herangehensweise an die anderen Typen ist etwas anders – siehe später.
Andere String-Operations-Member-Funktionen
Die Signaturen anderer String-Operationsfunktionen sind:
size_type find_first_of(constbasic_string&P,Größe_Typ Pos= 0) constkeine Ausnahme;size_type find_first_of(constDiagramm*S,Größe_Typ Pos,size_type n) const;
size_type find_first_of(constDiagramm*S,Größe_Typ Pos= 0) const;
size_type find_first_of(diagramm c,Größe_Typ Pos= 0) const;
size_type find_last_of(constbasic_string&P,Größe_Typ Pos=npos) constkeine Ausnahme;
size_type find_last_of(constDiagramm*S,Größe_Typ Pos,size_type n) const;
size_type find_last_of(constDiagramm*S,Größe_Typ Pos=npos) const;
size_type find_last_of(diagramm c,Größe_Typ Pos=npos) const;
size_type find_first_not_of(constbasic_string&P,Größe_Typ Pos= 0) constkeine Ausnahme;
size_type find_first_not_of(constDiagramm*S,Größe_Typ Pos,size_type n) const;
size_type find_first_not_of(constDiagramm*S,Größe_Typ Pos= 0) const;
size_type find_first_not_of(diagramm c,Größe_Typ Pos= 0) const;
size_type find_last_not_of(constbasic_string&P,Größe_Typ Pos=npos) constkeine Ausnahme;
size_type find_last_not_of(constDiagramm*S,Größe_Typ Pos,size_type n) const;
size_type find_last_not_of(constDiagramm*S,Größe_Typ Pos=npos) const;
size_type find_last_not_of(diagramm c,Größe_Typ Pos=npos) const;
Abschluss
C++ hat String-Literale und String-Objekte. Das String-Objekt verfügt über eine Sammlung von Zeichen in Folge, ähnlich einem Array von Zeichen in Folge. Der Unterschied zwischen der String-Sammlung und einem Array besteht darin, dass die String-Sammlung in der Länge wachsen oder in der Länge schrumpfen kann. Ein String-Objekt wird aus einer String-Klasse instanziiert (konstruiert). Ein String-Objekt ist eine Datenstruktur mit Memberfunktionen. Die Memberfunktionen können in die Überschriften Objektkonstruktion, Elementzugriff, Stringkapazität, Stringmemberfunktionen mit Iteratorargumenten und Rückgabetypen und Stringmodifikatoren eingeteilt werden. String-Gleichheit und relationale Operatoren existieren ebenfalls.