Metti byte da unsigned char array a std :: string usando la funzione memcpy()

Question

Ho variabile std :: string. E ho bisogno di mettere alcuni byte dalla serie di caratteri non firmati ad esso. Conosco il primo byte e il numero.

Posso usare la funzione std :: string :: assign. L'ho fatto.

Ma voglio risolvere quel problema in modo corretto utilizzando la funzione memcpy.

std::string newString; 
memcpy(&newString, &bytes[startIndex], length); 

So che è sbagliato. Ho ricercato e trovato alcune idee usando std :: vector.

Please help me per trovare la soluzione più elegante per questo problema.

Answer 1

Dal momento che siamo solo la costruzione della stri ng, v'è un costruttore std::string che prende due iteratori:

template< class InputIt > 
basic_string(InputIt first, InputIt last, 
       const Allocator& alloc = Allocator()); 

che possiamo fornire:

std::string newString(&bytes[startIndex], &bytes[startIndex] + length); 

Se non stiamo costruendo la stringa e siamo invece di assegnare ad uno già esistente, si dovrebbe preferisco ancora usare assign(). Questo è esattamente ciò che la funzione è per:

oldString.assign(&bytes[startIndex], &bytes[startIndex] + length); 

Ma se davvero ostini a memcpy() per qualche ragione, allora avete bisogno di fare in modo che la stringa in realtà ha dati sufficienti per essere copiati in. E poi basta copiarlo usando &str[0] come indirizzo di destinazione ^{e dagger;}:

oldString.resize(length); // make sure we have enough space! 
memcpy(&oldString[0], &bytes[startIndex], length); 

---

^{& pugnale;} Pre-C++ 11 non è tecnicamente garantito che le stringhe siano memorizzate in memoria in modo contiguo, sebbene in pratica ciò sia avvenuto comunque.

Answer 2

è necessario impostare la dimensione della stringa in modo che non ci sarà un buffer di dimensioni adeguate per ricevere i dati, e il cast del constness fuori del puntatore si ottiene da data()

std::string newString; 
newString.resize(length); 
memcpy((char*)newString.data(), &bytes[startIndex], length); 

naturalmente tutti questo è nel regno di un comportamento indefinito, ma non meno standard.

Answer 3

Si tratta di un hack e come hai detto modo sbagliato, ma è possibile, in quanto garantisce STL che std::string ha stoccaggio contigue:

std::string str(32, '\0'); 
std::strcpy(const_cast<char*>(str.data()), "REALLY DUDE, IT'S ILLEGAL WAY"); 

Naturalmente, è possibile utilizzare std::memcpy nello stesso modo (io ho usato strcpy solo copia terminazione null string) ...

Nel tuo caso:

str.resize(length); 
memcpy(const_cast<char*>(str.data()), bytes + startIndex, length);