c++ - Può una std::string contenere null incorporati?



stdstring c-strings null-terminated (5)

Sì questo è valido.

Puoi avere un carattere nullo nel mezzo della stringa.

Tuttavia, se si utilizza una std :: string con un carattere null nel mezzo con una funzione di stringa ac in città di comportamento non definito e nessuno vuole essere lì !!!:

 int n = strlen( strWithNullInMiddle.c_str() ); // Boom!!!

Per le stringhe C regolari, un carattere nullo '\0' indica la fine dei dati.

Che dire di std::string , posso avere una stringa con caratteri null incorporati?


Sì, puoi avere null incorporati nella tua std::string .

Esempio:

std::string s;
s.push_back('\0');
s.push_back('a');
assert(s.length() == 2);

Nota: il membro c_str() std::string aggiungerà sempre un carattere null al buffer di caratteri restituito; Tuttavia, il membro data() std::string può o non può aggiungere un carattere nullo al buffer di char restituito.

Fai attenzione all'operatore + =

Una cosa da tenere a mente è non usare l' operator+= con un char* sull'RHS. Si sommerà solo fino al carattere null.

Per esempio:

std::string s = "hello";
s += "\0world";
assert(s.length() == 5);

Il modo corretto:

std::string s = "hello";
s += std::string("\0world", 6);
assert(s.length() == 11);

Memorizzare i dati binari più comuni per usare std :: vector

In genere è più comune usare std::vector per archiviare dati binari arbitrari.

std::vector<char> buf;
buf.resize(1024);
char *p = &buf.front();

Probabilmente è più comune poiché i membri c_str() e c_str() std::string restituiscono i puntatori const in modo che la memoria non sia modificabile. con & buf.front () sei libero di modificare direttamente il contenuto del buffer.


Puoi, ma perché vorresti? L'incorporamento di NUL in una stringa std ::: è solo una richiesta di guai, perché le funzioni a cui si passa una stringa std :: può usare molto bene il membro c_str () e la maggior parte supporrà che il primo NUL indichi la fine della stringa. Quindi questa non è una buona idea da fare. Si noti inoltre che in UTF-8, solo '\ 0' genererà uno 0, quindi anche per scopi i18n, non vi è alcuna giustificazione per l'incorporamento di NUL.


Sì. Una std :: string è solo un vector<char> con vantaggi.

Tuttavia, fai attenzione a passare una bestia simile a qualcosa che chiama .c_str() e si ferma allo 0.


È complicato.

Innanzitutto, C ++ non è garbage collection. Pertanto, per ogni nuovo, deve esserci una cancellazione corrispondente. Se non si inserisce questa eliminazione, si verifica una perdita di memoria. Ora, per un caso semplice come questo:

std::string *someString = new std::string(...);
//Do stuff
delete someString;

Questo è semplice Ma cosa succede se "Do stuff" lancia un'eccezione? Spiacenti: perdita di memoria. Cosa succede se i problemi "Do stuff" return presto? Spiacenti: perdita di memoria.

E questo è per il caso più semplice . Se ti capita di restituire quella stringa a qualcuno, ora devono cancellarla. E se lo passano come argomento, la persona che lo riceve deve eliminarlo? Quando dovrebbero eliminarlo?

Oppure, puoi semplicemente fare questo:

std::string someString(...);
//Do stuff

Nessuna delete . L'oggetto è stato creato sullo "stack" e verrà distrutto una volta che sarà fuori dal campo di applicazione. È anche possibile restituire l'oggetto, trasferendo così il suo contenuto alla funzione di chiamata. È possibile passare l'oggetto alle funzioni (in genere come riferimento o riferimento const: void SomeFunc(std::string &iCanModifyThis, const std::string &iCantModifyThis) . E così via.

Tutto senza new e delete . Non c'è dubbio su chi possiede la memoria o chi è responsabile della sua eliminazione. Se fate:

std::string someString(...);
std::string otherString;
otherString = someString;

Resta inteso che otherString ha una copia dei dati di someString . Non è un puntatore; è un oggetto separato. Possono capitare di avere gli stessi contenuti, ma puoi cambiarne uno senza influenzare l'altro:

someString += "More text.";
if(otherString == someString) { /*Will never get here */ }

Vedi l'idea?





c++ stdstring c-strings null-terminated