Im Bereich der C++-Programmierung ist die Priorisierung von Effizienz und Leistung von entscheidender Bedeutung. Die in C++17 eingeführte Klasse „std::string_view“ stellt eine vielseitige und speichereffiziente Alternative zur herkömmlichen String-Manipulation dar. Im Kern ist „std::string_view“ ein nicht besitzender Verweis auf eine Zeichenfolge, die üblicherweise einen Teilstring eines größeren Strings darstellt. Im Gegensatz zu „std::string“, das seine Daten besitzt und den Speicher intern verwaltet, arbeitet „std::string_view“ ohne Besitz der zugrunde liegenden Daten. Diese Eigenschaft macht es besonders wertvoll für Szenarien, in denen der Mehraufwand für das Kopieren oder Verwalten des Speichers unerwünscht ist. In diesem Artikel werden wir die verschiedenen Beispiele untersuchen, um die Verwendung von „std::string_view“ in C++ zu verstehen.
Beispiel 1: Effizientes String-Handling
In der modernen C++-Entwicklung ist eine effiziente String-Verarbeitung entscheidend für die Optimierung der Leistung und Ressourcennutzung. Es ermöglicht einen effizienten Zugriff und eine effiziente Bearbeitung von Zeichenfolgen, ohne dass eine Neuzuweisung oder Duplizierung des Speichers erforderlich ist. Um dieses Konzept zu veranschaulichen, schauen wir uns ein praktisches Beispiel an.
Betrachten Sie den folgenden Codeausschnitt:
#include
#include
void ProcessStringView ( std::string_view strView ) {
std::cout << 'Länge: ' << strView.length ( ) << std::endl;
std::cout << 'Inhalt: ' << strView << std::endl;
}
int main ( ) {
std::string originalString = „Effizientes String-Handling“ ;
std::string_view viewOfString ( originalString ) ;
ProcessStringView ( viewOfString ) ;
zurückkehren 0 ;
}
In diesem Beispiel haben wir die Funktion „processStringView“, die „std::string_view“ als Parameter verwendet. Die Funktion gibt dann die Länge und den Inhalt der String-Ansicht mithilfe der Standardausgabe aus. Die Hauptfunktion initialisiert den „std::string“ namens „originalString“ mit dem Wert „Efficient String Handling“. Anschließend wird die „std::string_view“ mit dem Namen „viewOfString“ erstellt, die sich auf den Inhalt von „originalString“ bezieht.
Durch die Übergabe von „viewOfString“ an die Funktion „processStringView“ können wir die Operationen an der Zeichenfolge effizient ausführen, sodass keine zusätzlichen Speicherzuweisungen erforderlich sind. „std::string_view“ ist eine einfache Referenz auf die zugrunde liegende Zeichenfolge von „originalString“, ohne die Daten zu kopieren.
Hier ist die generierte Ausgabe:
Beispiel 2: Interoperabilität mit Legacy-Code
Im Bereich der C++-Entwicklung ist die nahtlose Integration neuer und alter Codebasen oft ein entscheidendes Anliegen. Mit „std::string_view“ können Entwickler mühelos mit Legacy-Funktionen interagieren, die die „const char“-Zeiger zurückgeben.
Betrachten Sie das folgende Beispiel, das die praktische Verwendung von „std::string_view“ für die Interoperabilität demonstriert. Hier haben wir eine Legacy-Funktion namens „legacyFunction()“, die einen „const char“-Zeiger zurückgibt:
#include#include
const char * LegacyFunktion ( ) {
zurückkehren „Legacy-String“ ;
}
int main ( ) {
std::string_view LegacyStrView ( LegacyFunktion ( ) ) ;
std::cout << „Legacy-String-Ansicht:“ << LegacyStrView << std::endl;
zurückkehren 0 ;
}
Wir beginnen mit der Definition einer Legacy-Funktion namens „legacyFunction()“, die einen „const char“-Zeiger zurückgibt, der eine Zeichenfolge darstellt, die als „Legacy String“ gekennzeichnet ist. Um diese Altdaten nahtlos in unser modernes C++-Programm zu integrieren, verwenden wir „std::string_view“. Insbesondere in der Funktion main() erstellen wir eine Instanz von „std::string_view“ mit dem Namen „legacyStrView“ und initialisieren sie mit dem Ergebnis der Legacy-Funktion. Diese Instanziierung ermöglicht es uns, den alten „const char“-Zeiger effizient zu kapseln und damit zu arbeiten.
Dadurch können wir auf die Legacy-Zeichenfolge zugreifen und diese bearbeiten, ohne auf unnötiges Kopieren von Daten zurückgreifen zu müssen, wodurch sowohl Effizienz als auch Kompatibilität gewahrt bleiben. Der letzte Schritt im Code besteht darin, „std::cout“ zu verwenden, um den Inhalt der alten Zeichenfolgenansicht zu drucken.
Die ausgeführte Ausgabe ist:
Beispiel 3: Verbesserte Verarbeitung von String-Literalen
String-Literale werden in C++ traditionell als Arrays von Zeichen dargestellt. „std::string_view“ vereinfacht die Arbeit mit String-Literalen, indem es eine praktische Schnittstelle bereitstellt. Indem „std::string_view“ einen direkten Zugriff auf das zugrunde liegende Zeichenarray ermöglicht, ohne dass explizite Konvertierungen erforderlich sind, optimiert es die Vorgänge für Zeichenfolgenliterale.
#include#include
int main ( ) {
const char * myLiteral = „Hallo, String View!“ ;
std::string_view literalView ( myLiteral ) ;
std::cout << „Erstes Zeichen:“ << literalView [ 0 ] << std::endl;
size_t position = literalView.find ( „Zeichenfolge“ ) ;
std::cout << „Teilstring-Position:“ << Position << std::endl;
zurückkehren 0 ;
}
In diesem Beispiel wird ein „Hello, String View!“ angezeigt. Dem „myLiteral“-Zeiger wird ein String-Literal zugewiesen. Die Einführung von „std::string_view“ ermöglicht eine effizientere Darstellung dieses Strings, ohne dass sein Inhalt kopiert werden muss. Das „literalView“-Objekt wird mithilfe des „myLiteral“-Zeigers erstellt, der es uns ermöglicht, die zugrunde liegende Zeichenfolge anzuzeigen und zu bearbeiten.
Die Verwendung von „std::string_view“ ermöglicht einen einfachen Zugriff auf einzelne Zeichen innerhalb der Zeichenfolge. Im Codeausschnitt ruft „literalView[0]“ das erste Zeichen der Zeichenfolge ab und gibt es aus, was die Einfachheit und Direktheit des Zugriffs auf die Elemente demonstriert. Die „find“-Methode von „std::string_view“ wird verwendet, um die Position des „String“-Teilstrings innerhalb des Originalstrings zu bestimmen.
Beispiel 4: Teilstring-Extraktion
Die Aufgabe der Teilzeichenfolgenextraktion besteht darin, einen Teil einer bestimmten Zeichenfolge basierend auf bestimmten Kriterien wie der Position eines Trennzeichens abzurufen. Die Möglichkeit, die Teilzeichenfolgen mühelos zu extrahieren, ist eine leistungsstarke Funktion von „std::string_view“. Stellen Sie sich ein Szenario vor, in dem wir einen Teil einer Zeichenfolge basierend auf einem Trennzeichen extrahieren müssen:
#include#include
int main ( ) {
std::string fullString = „Apfel-Orange-Banane“ ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , delimiterPos ) ;
std::cout << „Extrahierter Teilstring:“ << Teilzeichenfolge << std::endl;
zurückkehren 0 ;
}
In diesem Codeausschnitt beginnen wir mit der Deklaration eines ursprünglichen Strings, „fullString“, der mit dem Wert „apple-orange-banana“ initialisiert wird. Unser Ziel ist es, die Teilstring-Extraktion durchzuführen. Um dies zu erreichen, verwenden wir die Funktion „find“, die von der C++-Standardbibliothek bereitgestellt wird.
Sobald wir die Position des Trennzeichens innerhalb des „fullString“ identifiziert haben, der in der Variablen „delimiterPos“ gespeichert ist, extrahieren wir den gewünschten Teilstring. Die Funktion „substr“ wird für die ursprüngliche Zeichenfolge aufgerufen und gibt die Startposition (0) und die Länge der Teilzeichenfolge an, die genau der Position des Trennzeichens entspricht. Dieser Vorgang führt zur Erstellung der „std::string_view“ mit dem Namen „subString“, die den Teil der ursprünglichen Zeichenfolge vom Anfang bis zum Trennzeichen darstellt.
Beispiel 5: Speichereffiziente Datenstrukturen
Der „std::string_view“ spielt eine entscheidende Rolle beim Entwurf der speichereffizienten Datenstrukturen. Anstatt mehrere Kopien von Zeichenfolgen zu speichern, können Datenstrukturen die „std::string_view“-Instanzen speichern und so den Speicheraufwand reduzieren.
#include#include
Strukturdatensatz {
std::string_view name;
int Alter;
} ;
int main ( ) {
Person aufzeichnen = { 'John Doe' , 30 } ;
std::cout << 'Name: ' << Name der Person << ', Alter: ' << Persönlichkeit << std::endl;
zurückkehren 0 ;
}
In diesem Codeausschnitt demonstrieren wir die Verwendung von „std::string_view“ innerhalb einer speichereffizienten Datenstruktur. Wir definieren eine „Record“-Struktur, die ein „std::string_view“-Mitglied namens „name“ und ein ganzzahliges Mitglied namens „age“ umfasst. Die Verwendung von „std::string_view“ in diesem Kontext ermöglicht es uns, eine kompakte Darstellung eines Strings zu erstellen, ohne dass zusätzliche Speicherzuweisung erforderlich ist.
In der „main“-Funktion instanziieren wir ein „Record“-Objekt namens „person“ mit dem Namen „John Doe“ und dem Alter von 30 Jahren. Das „std::string_view“-Mitglied „name“ dient als nicht besitzende Ansicht von die dem Namen entsprechenden Zeichendaten, wodurch die Notwendigkeit entfällt, den String-Inhalt zu duplizieren. Das „std::cout << „Name:“ << person.name << „, Alter:“ << person.age << std::endl;“ Die Anweisung gibt den Namen und das Alter der Person aus, die im „Record“-Objekt gespeichert sind.
Abschluss
In der sich ständig weiterentwickelnden Landschaft der C++-Entwicklung sticht „std::string_view“ als wertvolle Ergänzung zum Toolkit des Programmierers hervor. Die in diesem Artikel dargestellten Beispiele verdeutlichen die Anpassungsfähigkeit und Nützlichkeit von „std::string_view“ im Bereich der C++-Programmierung. Von effizienter String-Manipulation und nahtloser Interoperabilität mit Legacy-Code bis hin zu speichereffizienten Datenstrukturen ist „std::string_view“ wertvoll für Entwickler, die eine verbesserte Leistung und optimierten Code in verschiedenen Szenarien suchen. Diese realen Szenarien zeigen, wie „std::string_view“ den Code optimieren, unnötigen Speicheraufwand reduzieren und zur Gesamteffizienz von C++-Anwendungen beitragen kann.