Die String-Klasse in der STL-Bibliothek (Standard Template Library) ist eine String-Klasse, die verschiedene Methoden und Funktionen zum Verwalten von Strings bereitstellt. Dabei handelt es sich um eine Zeichenfolge variabler Länge, deren Größe sich automatisch an Änderungen in der Länge der Zeichenfolge anpasst.

In der Vergangenheit haben wir Strings bedient, indem wir verwandte Funktionen selbst implementiert haben, und wenn wir nicht aufpassten, kam es zu Speicherverlusten. In C++ verwenden wir lieber die String-Klasse, um Vorgänge im Zusammenhang mit Strings abzuschließen.

Die Verwendung der String-Klasse hat gegenüber der Verwendung von Strings in der C-Sprache folgende Vorteile:

Sicherer: C-Sprachzeichenfolgen verfügen nicht über eigene Längeninformationen, was leicht zu Sicherheitsproblemen führen kann, z. B. zu Speicherüberschreitungen. Die String-Klasse enthält Informationen zur String-Länge, wodurch solche Probleme vermieden werden können.
Bequemer: Die Verarbeitung von Zeichenfolgen in der C-Sprache erfordert eine Reihe von Funktionen wie strlen, strcmp, strcat usw., deren Verwendung umständlich ist. Die String-Klasse bietet eine Reihe von Methoden wie Länge, Vergleich, Anhängen usw., die intuitiver und bequemer zu verwenden sind.
Flexibler: Die String-Klasse kann die Länge des Strings dynamisch ändern, während die Länge des Strings in der C-Sprache normalerweise fest ist.
Effizienter: Viele Optimierungen werden innerhalb der String-Klasse implementiert, z. B. Referenzzählung und Copy-on-Write-Technologien werden zum Kopieren von Strings verwendet, sodass die Leistung höher ist als die von C-Sprachstrings.

2. Gemeinsame Schnittstellen der String-Klasse

2.1 Häufig verwendete Strukturen

In C++98 werden 7 Konstruktoren unterstützt:

Aber wir werden nur fünf davon erklären:

1. Leerer String-Aufbau: string();

Dieser Konstruktor erstellt eine leere Zeichenfolge mit einer Länge von 0 Zeichen, die Kapazität ist jedoch nicht unbedingt Null. Beispielsweise beträgt die Kapazität eines leeren Zeichenfolgenobjekts unter VS 15, was in verschiedenen Umgebungen unterschiedlich sein kann, hauptsächlich um häufige Erweiterungen zu vermeiden Operationen.

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string s1; //创建一个空字符串
	cout << s1 << endl;
	cout << s1.capacity() << endl;
}

2. C-String-Konstruktion: **string(const char* s);**

Konstruiert ein String-Objekt aus einer nullterminierten Zeichenfolge (C-String).

int main()
{
	string s1("hello world!");
	cout << s1 << endl;

}

3. Konstruktion kopieren: string(const string& str);

Konstruiert ein Objekt aus einem vorhandenen String-Objekt.

int main()
{
	string s1("hello world!");
	cout << s1 << endl;
	string s2(s1);
	cout << s2 << endl;
}

4. Zeichenfüllkonstruktion: string(size_t n, char c);

Konstruiert ein String-Objekt aus n Zeichen.

int main()
{
	string s1(5, 'c');
	cout << s1 << endl;
}

5. Iteratorkonstruktion: template <class InputIterator> string(InputIterator zuerst, InputIterator zuletzt);

Verwenden Sie den Iteratorbereich, um ein Zeichenfolgenobjekt zu erstellen.

int main()
{
	string s1(5, 'c');
	cout << s1 << endl;
	string s2(s1.begin(), s1.end());
	cout << s2 << endl;
}

2.2 String-Kapazitätsbetrieb

1. size_t size(),size_t length()

Sowohl size() als auch length() geben die effektive Zeichenlänge der Zeichenfolge zurück, und die Implementierungsprinzipien der beiden Funktionen sind genau gleich. Size() wird eingeführt, um mit den Schnittstellen anderer Container konsistent zu sein.

int main()
{
	string s1(5, 'c');
	cout << s1.length() << endl;
	cout << s1.size() << endl;
}

2. size_t Capacity() const

Capacity () ist die Gesamtgröße des zurückgegebenen Speicherplatzes. Die anfängliche Kapazität des Objekts unter VS beträgt 15. Wenn das gespeicherte Objekt diese Größe überschreitet, wird der Speicherplatz geöffnet und die Daten werden im neu geöffneten Speicherplatz gespeichert.

int main()
{
	string s1(5, 'c');
	cout << s1.capacity() << endl;
	string s2(16, 'c');
	cout << s2.capacity() << endl;
}

3. bool empty() const

Überprüfen Sie, ob die Zeichenfolge eine leere Zeichenfolge ist. Geben Sie true und nicht false zurück.

int main()
{
	string s1(5, 'c');
	if (s1.empty())
	{
		cout << "true" << endl;
		cout << "空" << endl;
	}
	else
	{
		cout << "false" << endl;
		cout << "非空" << endl;
	}
}

4. void clear()

Löschen Sie gültige Zeichen im Objekt.

int main()
{
	string s1("hello world!");
	cout << s1 << endl;
	cout << "--------------------------------" << endl;
	s1.clear();
	cout << s1 << endl;
}

5. Leerreserve (size_t n = 0)

Reserve () dient dazu, Platz für das Objekt zu reservieren. Wenn wir den von der Zeichenfolge benötigten Platz im Voraus kennen, können wir ihn im Voraus öffnen, um den durch häufige Erweiterung verursachten Leistungsverbrauch zu vermeiden. Wenn der Parameter „reserve“ kleiner als die Größe des zugrunde liegenden Speicherplatzes der Zeichenfolge ist, verarbeitet „reserve“ die Kapazität nicht. (Um die Sicherheit des Programms zu gewährleisten, wird Reserve () im Allgemeinen etwas mehr Platz freigeben.)

int main()
{
	string s1(10,'x');
	s1.reserve(20);
	cout << s1.capacity() << endl;
	s1.reserve(2);
	cout << s1.capacity() << endl;
}

6. void resize(size_t n), void resize(size_t char c)

Ändern Sie die effektive Anzahl von Zeichen auf n und füllen Sie den zusätzlichen Platz mit dem Zeichen c. Wenn n kleiner als die Anzahl der effektiven Zeichen ist, besteht das Wesentliche darin, Zeichen zu löschen. Reicht die Kapazität nicht aus, wird sie erweitert.

int main()
{
	string s1(10, 'x');
	cout << s1 << endl;
	s1.resize(20, 'c');
	cout << s1 << endl;
	s1.resize(2);
	cout << s1 << endl;
}

2.3 Zugriff auf Klassenobjekte

1. char& Operator[](size_t pos)，const char& Operator[](size_t pos) const

Gibt das Zeichen an der Position zurück und kann nicht konstante Objekte ändern.

int main()
{
	string s1(10, '1');
	cout << s1 << endl;
	s1[4] = '0';
	cout << s1 << endl;
	for (int i = 0; i < 10; i++)
	{
		cout << s1[i] << ' ';
	}
}

2. begin()、end()

begin() gibt einen Iterator an die Position des ersten Zeichens zurück und end() gibt einen Iterator an die nächste Position des letzten Zeichens zurück. Sowohl begin() als auch end() geben konstante Versionen ihrer selbst zurück.

int main()
{
	string s1(10, '1');
	auto it = s1.begin();
	for (; it < s1.end(); it++)
	{
		cout << *it;
	}
}

3. rbegin()、rend()

rbegin() nimmt einen umgekehrten Iterator, der auf seinen umgekehrten Anfang zeigt, und rend() nimmt einen umgekehrten Iterator, der auf das vorherige theoretische Element an seinem umgekehrten Ende zeigt.

int main()
{
	string s1("123456789");
	cout << s1 << endl;
	auto it = s1.rbegin();
	for (; it < s1.rend(); it++)
	{
		cout << *it;
	}
}

2.4 Funktion zur Verarbeitung von Zeichenfolgenobjekten

1. push_back()

Fügen Sie am Ende der Zeichenfolge das Zeichen c ein.

int main()
{
	string s1;
	s1.push_back('1');
	cout << s1;
}

2. append()

Die Funktion append() verfügt in C++98 über sechs überladene Formen, die zum Anhängen einer Zeichenfolge nach einer Zeichenfolge verwendet werden.

int main()
{
	string s1("hello");
	string s2(" world");
	cout << s1 << endl;
	s1.append(s2); //在s1结尾追加一个s1
	cout << s1 << endl;
	s1.append(s2, 1, 2); //在s1结尾追加s1的下标为1往后的俩个字符
	cout << s1 << endl;
	s1.append("C串");   //在s1后追加一个C串
	cout << s1 << endl;
	s1.append("123456", 2);//在s1后追加字符串的前 n 个字符。
	cout << s1 << endl;
	s1.append(5, 'c');  //在s1后追加5个字符‘c’
	cout << s1 << endl;
	string s3("CSDN");
	s1.append(s3.begin(), s3.end());//在s1后追加一个迭代器区间
	cout << s1 << endl;
}

3. Operator+=

„operator+=()“ und „append()“ haben ähnliche Funktionen, sie hängen beide Inhalte nach der Zeichenfolge an, wir bevorzugen jedoch die Verwendung von „operator+=“ in der tatsächlichen Entwicklung.

int main()
{
	string s1("hello ");
	string s2("world!");
	s1 += s2;
	cout << s1 << endl;
}

4. c_str()

c_str() gibt die erste Adresse des String-Objekts zum Speichern des Strings zurück, und Benutzer können diese Schnittstelle verwenden, um sich an bestimmte Szenarien in der C-Sprache anzupassen.

int main()
{
	string s1("hello world!");
	printf("%s", s1.c_str());
}

5. insert()

insert() unterstützt das Einfügen von Zeichenfolgen an der Pos-Position. Da das Einfügen an der Pos-Position jedoch das Verschieben von Elementen erfordert und das Verschieben von Elementen die Leistung beeinträchtigt, sollte insert() seltener verwendet werden. insert() hat mehrere überladene Formen, wie folgt:

int main()
{
	string s1("string");
	cout << s1 << endl;
	s1.insert(2, "*********");
	cout << s1 << endl;
}

6. löschen()

Erase() löscht einen Teil der Zeichenfolge, ändert jedoch nicht die Kapazität des Zeichenfolgenobjekts. Wenn die angegebene Anzahl der gelöschten Zeichen größer ist als die Anzahl der Zeichen nach dem Pos-Bit, werden alle nachfolgenden Zeichen gelöscht. Wenn kein Pos-Bit angegeben ist, wird der String standardmäßig geleert. Wenn die Anzahl der Löschungen nicht angegeben ist, ist der Standardwert die vorzeichenlose Ganzzahl npos (-1), was ungefähr 4,2 Milliarden entspricht, und alle Zeichenfolgen nach dem Pos-Bit werden gelöscht.

int main()
{
	string s1("1234567890");
	s1.erase(2, 3);//从pos位2开始依次删除三个字符，即删除"345"
	cout << s1 << endl;
	s1.erase(s1.begin() + 5);
	cout << s1 << endl;//删除迭代器位置的字符
	s1.erase(s1.begin(), s1.begin() + 2);//删除beigin()位置和后面1位字符
	cout << s1 << endl;
}

7. find()、rfind()

Die Funktion find() wird verwendet, um herauszufinden, ob ein bestimmtes Zeichen oder eine Zeichenfolge in einer bestimmten Zeichenfolge enthalten ist, und sucht von der Pos-Position aus rückwärts, während rfind() von der Pos-Position aus vorwärts sucht. Wenn es gefunden wird, wird das Pos-Bit des ersten Vorkommens des Zeichens oder das Pos-Bit des ersten Vorkommens der Zeichenfolge zurückgegeben. Gibt npos (vorzeichenlose Ganzzahl „-1“) zurück, wenn nicht gefunden.

int main()
{
	string s1("hello world");
	size_t pos = s1.find("llo", 0);
	cout << pos << endl;
}

8. substr()

substr() ruft die n Zeichen nach pos einschließlich des pos-Bits ab und gibt ein String-Objekt zurück. Wenn die Länge n nicht angegeben ist, ruft es standardmäßig alle folgenden Zeichen einschließlich des pos-Bits ab und gibt ein String-Objekt zurück.

int main()
{
	string s1("123456789");
	cout << s1 << endl;
	string s2(s1.substr(2, 5));
	cout << s2 << endl;
}

9. getline()

Zeichen werden aus istream extrahiert und in str gespeichert, bis das Trennzeichen delim (oder (2) Newline „\n“) gefunden wird. Die Extraktion stoppt auch, wenn das Dateiende erreicht wird oder andere Fehler bei Eingabevorgängen auftreten. Wenn ein Trennzeichen gefunden wird, wird es extrahiert und verworfen (d. h. es wird nicht gespeichert, die nächste Eingabeoperation beginnt danach). Beachten Sie, dass alles vor dem Aufruf durch die neu extrahierte Sequenz ersetzt wird. Jedes extrahierte Zeichen wird an die Zeichenfolge angehängt, als ob sein Mitglied push_back aufgerufen würde. (Verwenden Sie keine Leerzeichen als Trennzeichen, Sie können Leerzeichen lesen)

[C++ Essence Shop] 9. STL-String

1. Vorteile der String-Klasse