Ci sono motivi per cui l'idioma StringPiece/StringRef non è più popolare?

Question

Dalla documentazione del 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. 

Esempio di utilizzo:

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"); 
} 

Questo mi sembra un'ottimizzazione così importante ed evidente che non riesco a capire il motivo per cui non è più diffuso, e perché una classe simile a StringPiece non è già nello standard.

Ci sono motivi per cui non dovrei sostituire l'uso dei parametri string e char* nel mio codice con questa classe? C'è qualcosa di simile già nelle librerie standard C++?

UPDATE. Ho appreso che la fonte di LLVM utilizza un concetto simile: la classe StringRef.

Answer 1

Perché preoccuparsi? Con copia elision e/o passare per riferimento, di solito si possono evitare anche allocazioni di memoria per std::string.

La situazione delle stringhe in C++ è abbastanza confusa, senza aggiungere altre classi di stringhe.

Se il linguaggio doveva essere riprogettato da zero o se la compatibilità con le versioni precedenti non era un problema, questo è uno dei molti possibili miglioramenti che potrebbero essere apportati alla gestione delle stringhe in C++. Ma ora che siamo bloccati sia con lo char* sia con lo std::string, l'aggiunta di una classe in stile stringa nel mix causerebbe molta confusione, con un beneficio limitato.

A parte questo, non è lo stesso effetto ottenuto più idiomaticamente con un paio di iteratori? Se voglio passare una sequenza di caratteri, sia che appartengano a una stringa o a char*, perché non dovrei semplicemente usare un paio di iteratori per delimitarli?

Answer 2

Lo standard sta tentando di spostarsi da const char * in favore di stringa del tutto, quindi aggiungere ulteriori opzioni per la conversione è inutile.

Si noti inoltre che un programma ben formato dovrebbe utilizzare sia string che const char * in tutto;).

Answer 3

StringPiece mantiene un puntatore ai dati di stringa passati al suo costruttore. Quindi si basa sulla durata di quella stringa per essere più lunga di StringPiece. Questo è garantito se si utilizza StringPiece come parametro di funzione; non così se per esempio stai tenendo una copia della stringa in un membro della classe.

Non è così universale come std :: string, e non è sicuramente un sostituto per esso.

Answer 4

La domanda ha già avuto una risposta molto buona, ma per dare un po 'più di contesto, il pattern StringPiece è ampiamente utilizzato internamente a Google ed è stato per molti anni. È fortemente raccomandato nelle linee guida sulla codifica di Google, che è quasi sicuramente il motivo per cui Chrome (e successivamente Chromium) l'hanno adottato.

Answer 5

StringPiece è ottimo ma i pezzi non sono nulli. Se è necessario passare a interfacce di livello inferiore che accettano stringhe con terminazione nulla, è necessario copiare il copione in una stringa terminata da null.

(Non tutti hanno acquistato in STL o std :: string.)

Answer 6

po 'più tardi, ma ...

idea alla base StringPiece è molto buona. La classe può acquisire sia std::string e const char * e passarli a una funzione. Ecco un esempio:

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 

Se la funzione accettati std::string in realtà la creazione di un oggetto temporaneo se si passa const char * e tutto il char è copiato (per esempio con memcpy).

Inoltre non è necessario preoccuparsi della vita notturna, perché si sta passando StringRef a funzione/metodo.

ci sono tale classe in:

• Google - StringPiece

• spinta - boost :: string_ref

• LLVM - stringRef

mia (incompleta) l'implementazione può essere vista qui:
https://github.com/nmmmnu/HM3/blob/master/include/stringref.h

Aggiornamento 2016:

In C++ 17, ci sono std::string_view. Non l'ho studiato nei dettagli, ma in generale ha la stessa idea. Anche simile alla mia implementazione ha constexpr c-tor, quindi puoi creare oggetti in fase di compilazione e usarlo insieme ad altre funzioni constexpr.