Wann sollte ich string_view in einer Schnittstelle verwenden?

Ich verwende eine interne Bibliothek , die zu imitieren eine entworfen wurden vorgeschlagen , C ++ Bibliothek , und irgendwann in den letzten Jahren sehe ich seine Oberfläche verändert verwenden std::stringzu string_view.

Also ändere ich pflichtgemäß meinen Code, um mich an die neue Oberfläche anzupassen. Leider muss ich einen std :: string-Parameter und einen std :: string-Rückgabewert übergeben. Mein Code hat sich also wie folgt geändert:

void one_time_setup(const std::string & p1, int p2) {
   api_class api;
   api.setup (p1, special_number_to_string(p2));
}

zu

void one_time_setup(const std::string & p1, int p2) {
   api_class api;
   const std::string p2_storage(special_number_to_string(p2));
   api.setup (string_view(&p1[0], p1.size()), string_view(&p2_storage[0], p2_storage.size()));
}

Ich verstehe wirklich nicht, was mir diese Änderung als API-Client gebracht hat, außer mehr Code (um es möglicherweise zu vermasseln). Der API-Aufruf ist weniger sicher (da die API den Speicher für ihre Parameter nicht mehr besitzt), hat wahrscheinlich die Arbeit meines Programms 0 gespeichert (aufgrund von Optimierungen, die Compiler jetzt ausführen können), und selbst wenn es Arbeit spart, wäre dies nur der Fall ein paar zuweisungen, die nach dem start oder in einer großen schleife irgendwo nicht mehr gemacht werden und nie mehr gemacht werden würden. Nicht für diese API.

Dieser Ansatz scheint jedoch den Ratschlägen zu folgen, die ich an anderer Stelle sehe, zum Beispiel die folgende Antwort :

Abgesehen davon sollten Sie seit C ++ 17 vermeiden, eine const std :: string & zugunsten einer std :: string_view zu übergeben:

Ich finde diesen Rat überraschend, da er das allgemeine Ersetzen eines relativ sicheren Objekts durch ein weniger sicheres (im Grunde genommen ein verherrlichter Zeiger und eine Länge) zu befürworten scheint, vor allem zu Optimierungszwecken.

Wann sollte string_view verwendet werden und wann nicht?

1. Muss die Funktionalität, die den Wert verwendet, den Besitz der Zeichenfolge übernehmen? Verwenden Sie in diesem Fall std::string(non-const, non-ref). Mit dieser Option können Sie einen Wert auch explizit verschieben, wenn Sie wissen, dass er im aufrufenden Kontext nie wieder verwendet wird.
2. Liest die Funktionalität nur den String? Wenn dies der std::string_viewFall ist, verwenden Sie (const, non-ref), da string_viewdies problemlos std::stringund char*ohne Ausgabe und ohne Anfertigung einer Kopie möglich ist. Dies sollte alle const std::string&Parameter ersetzen .

Letztendlich sollten Sie niemals den std::string_viewKonstruktor so aufrufen müssen, wie Sie es sind.std::stringhat einen Konvertierungsoperator , der die Konvertierung automatisch abwickelt.

A std::string_viewbringt einige der Vorteile von a const char*in C ++: Im Gegensatz zu std::stringeinem string_view

• besitzt kein Gedächtnis,
• reserviert keinen Speicher,
• kann mit einem gewissen Versatz in eine vorhandene Zeichenfolge zeigen, und
• hat eine Stufe weniger Zeiger-Indirektion als a std::string&.

Dies bedeutet, dass eine string_view häufig Kopien vermeidet, ohne dass rohe Zeiger verwendet werden müssen.

In modernem Code std::string_viewsollten fast alle Verwendungen von const std::string&Funktionsparametern ersetzt werden. Dies sollte eine quellkompatible Änderung sein, da dies std::stringeinen Konvertierungsoperator zu deklariert std::string_view.

Nur weil eine Zeichenfolgenansicht in Ihrem speziellen Anwendungsfall, in dem Sie ohnehin eine Zeichenfolge erstellen müssen, nicht hilft, bedeutet dies nicht, dass es im Allgemeinen eine schlechte Idee ist. Die C ++ - Standardbibliothek wurde eher aus Gründen der Allgemeinheit als der Benutzerfreundlichkeit optimiert. Das Argument „weniger sicher“ trifft nicht zu, da es nicht erforderlich sein sollte, die Zeichenfolgenansicht selbst zu erstellen.

Ich finde diesen Rat überraschend, da er das allgemeine Ersetzen eines relativ sicheren Objekts durch ein weniger sicheres (im Grunde genommen ein verherrlichter Zeiger und eine Länge) zu befürworten scheint, vor allem zu Optimierungszwecken.

Ich denke, das ist ein leichtes Missverständnis des Zwecks. Während es sich um eine "Optimierung" handelt, sollten Sie es sich wirklich so vorstellen, als ob Sie sich von der Verwendung von a abkoppeln müssten std::string.

Benutzer von C ++ haben Dutzende verschiedener Zeichenfolgenklassen erstellt. Zeichenfolgenklassen mit fester Länge, SSO-optimierte Klassen, wobei die Puffergröße ein Vorlagenparameter ist, Zeichenfolgenklassen, die einen Hashwert zum Vergleichen speichern, usw. Manche verwenden sogar COW-basierte Zeichenfolgen. Wenn es eine Sache gibt, die C ++ - Programmierer gerne tun, dann sind es Schreibzeichenfolgenklassen.

Dabei werden Zeichenfolgen ignoriert, die von C-Bibliotheken erstellt wurden und deren Eigentümer sie sind. Nackte char*s, vielleicht mit einer Größe von einer Art.

Wenn Sie also eine Bibliothek schreiben und eine nehmen const std::string&, muss der Benutzer jetzt die Zeichenfolge, die er verwendet hat, nehmen und in eine kopieren std::string. Vielleicht Dutzende Male.

Wenn Sie auf die zeichenfolgenspezifische std::stringSchnittstelle zugreifen möchten , warum sollten Sie die Zeichenfolge kopieren müssen ? Das ist so eine Verschwendung.

Die Hauptgründe, a nicht string_viewals Parameter zu verwenden, sind:

1. Wenn Ihr Endziel darin besteht, die Zeichenfolge an eine Schnittstelle zu übergeben, die eine mit NUL abgeschlossene Zeichenfolge ( fopenusw.) verwendet. std::stringwird garantiert, um NUL beendet zu werden; string_viewist nicht. Und es ist sehr einfach, eine Ansicht mit Teilzeichenfolgen zu versehen, damit sie nicht mit NUL abgeschlossen wird. Unterzeichenfolge a std::stringkopiert die Teilzeichenfolge in einen mit NUL abgeschlossenen Bereich.

   Für genau dieses Szenario habe ich einen speziellen NUL-terminierten string_view-Stiltyp geschrieben. Sie können die meisten Vorgänge ausführen, jedoch keine Vorgänge, die den NUL-terminierten Status aufheben (z. B. Trimmen vom Ende).

2. Probleme auf Lebenszeit. Wenn Sie das wirklich kopieren müssen std::stringoder das Array von Zeichen den Funktionsaufruf überlebt haben, geben Sie dies am besten im Voraus mit a an const std::string &. Oder einfach std::stringals Wertparameter. Auf diese Weise können Sie, wenn sie bereits über eine solche Zeichenfolge verfügen, sofort den Besitz der Zeichenfolge beanspruchen, und der Anrufer kann in die Zeichenfolge wechseln, wenn er keine Kopie der Zeichenfolge aufbewahren muss.