Gibt es Gründe, warum das StringPiece/StringRef-Idiom nicht beliebter ist?

Question

Aus der Dokumentation der StringPiece class in Chromium's source code:

// A string-like object that points to a sized piece of memory. 
// 
// Functions or methods may use const StringPiece& parameters to accept either 
// a "const char*" or a "string" value that will be implicitly converted to 
// a StringPiece. 
// 
// Systematic usage of StringPiece is encouraged as it will reduce unnecessary 
// conversions from "const char*" to "string" and back again. 

Beispiel:

void foo(StringPiece const & str) // Pass by ref. is probably not needed 
{ 
    // str has same interface of const std::string 
} 

int main() 
{ 
    string bar("bar"); 
    foo(bar); // OK, no mem. alloc. 

    // No mem. alloc. either, would be if arg. of "foo" was std::string 
    foo("baz"); 
} 

dies eine wichtige und offensichtliche Optimierung wie so scheint, dass ich kann nicht verstehen, warum es nicht mehr weit verbreitet ist, und warum Eine Klasse, die StringPiece ähnlich ist, ist nicht bereits im Standard enthalten.

Gibt es irgendwelche Gründe, warum ich die Verwendung von string und char* Parameter in meinem eigenen Code mit dieser Klasse nicht ersetzen sollte? Gibt es so etwas schon in den C++ - Standardbibliotheken?

UPDATE. Ich habe gelernt, dass die Quelle von LLVM ein ähnliches Konzept verwendet: die StringRef Klasse.

Answer 1

Weil warum stören? Mit Kopie Elision und/oder Pass by Referenz, Speicherzuweisungen für std::string kann in der Regel ebenfalls vermieden werden.

Die Zeichenfolge Situation in C++ ist verwirrend genug, wie es ist, ohne noch mehr String-Klassen hinzuzufügen.

Wenn die Sprache von Grund auf neu entwickelt werden sollte oder wenn Abwärtskompatibilität kein Problem war, dann ist dies eine von vielen möglichen Verbesserungen, die zur String-Behandlung in C++ gemacht werden könnten. Aber jetzt, da wir sowohl bei char* als auch bei std::string stecken bleiben, würde das Hinzufügen einer stringref-style-Klasse in die Mischung viel Verwirrung mit begrenztem Nutzen verursachen.

Abgesehen davon, wird nicht der gleiche Effekt idiomatisch mit einem Paar Iteratoren erreicht? Wenn ich eine Folge von Zeichen übergeben möchte, egal ob sie zu einer Zeichenfolge oder einer char* gehören, warum sollte ich nicht einfach ein Paar Iteratoren verwenden, um sie zu begrenzen?

Answer 2

Der Standard versucht, sich von const char * zugunsten von string ganz wegzubewegen, daher ist es nutzlos, weitere Optionen für die Konvertierung hinzuzufügen.

Beachten Sie auch, dass ein schönes gebildetes Programm entweder string oder const char * allround verwenden sollte;).

Answer 3

StringPiece behält einen Zeiger auf die Zeichenfolge Daten, die an seinen Konstruktor übergeben wird. Daher hängt es von der Lebensdauer dieser Zeichenfolge ab, länger als die StringPiece zu sein. Dies ist garantiert, wenn Sie StringPiece als Funktionsparameter verwenden. nicht so, wenn Sie zum Beispiel eine Kopie der Zeichenfolge in einem Klassenmitglied aufbewahren.

Es ist nicht ganz so universell wie Std :: String, und es ist definitiv kein Ersatz für es.

Answer 4

Die Frage wurde bereits sehr gut beantwortet, aber um mehr Kontext zu geben, ist das StringPiece Muster intern bei Google sehr weit verbreitet und ist seit vielen Jahren. Es wird dringend in den Codierungsrichtlinien von Google empfohlen, da Chrome (und anschließend Chromium) mit ziemlicher Sicherheit übernommen wird.

Answer 5

StringPiece ist großartig, aber die Stücke sind nicht null terminiert. Wenn Sie zu Interfaces auf niedrigerer Ebene übergehen müssen, die leere terminierte Strings verwenden, müssen Sie das stringpiece in eine nullterminierte Zeichenfolge kopieren.

(Nicht jeder hat in STL oder Std :: String gekauft.)

Answer 6

Bit später, aber ...

Idee hinter StringPiece ist sehr gut. Die Klasse kann sowohl std::string als auch const char * erfassen und an eine Funktion übergeben. Hier ein Beispiel:

void process(const StringRef s){ 
    // do something 
} 

process("Hello"); // const char * 
std::string s = "Hello"; 
process(s); // std::string 
process(std::string("Hello")); // std::string rvalue 

Wenn Funktion std::string akzeptierte Sie tatsächlich ein temporäres Objekt zu schaffen, wenn Sie const char * und ganz char passieren wird kopiert (zB mit memcpy).

Sie müssen sich auch keine Gedanken über die Lebenszeit machen, weil Sie StringRef an Funktion/Methode übergeben.

Es gibt solche Klasse in:

• Google - StringPiece

• Schub - boost :: string_ref

• LLVM - StringRef

Meine eigene (unvollständig) Implementierung kann hier gesehen werden:
https://github.com/nmmmnu/HM3/blob/master/include/stringref.h

-Update 2016:

In C++ 17 gibt es std::string_view. Ich habe es nicht im Detail studiert, aber im Allgemeinen hat es die gleiche Idee. Auch ähnlich wie meine Implementierung es constexpr c-tor, so können Sie Objekte zur Kompilierzeit erstellen und verwenden Sie es zusammen mit anderen constexpr Funktionen.