Setzen Sie Bytes von unsigned Char-Array zu std :: string mit memcpy() -Funktion

Question

Ich habe Std :: String-Variable. Und ich muss einige Bytes aus dem Array von unsignierten Zeichen dazu setzen. Ich kenne das erste Byte und das Bein.

ich die std verwenden können :: string :: assign Funktion. Ich habe es getan.

Aber ich will diese Frage in einem richtigen Weg Funktion mit dem Memcpy lösen.

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

Ich weiß, dass es falsch ist. Ich habe recherchiert und einige Ideen mit std :: vector gefunden.

Bitte mir helfen, die eleganteste Lösung für dieses Problem zu finden.

Answer 1

Da wir die Konstruktion nur die stri ng gibt es einen std::string Konstruktor, der zwei Iteratoren nimmt:

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

, die wir zur Verfügung stellen können:

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

Wenn wir nicht die Zeichenfolge Konstruktion und stattdessen die Zuordnung zu einer bestehenden sind, sollten Sie bevorzugen Sie immer noch assign() zu verwenden. Das ist genau das, was diese Funktion ist für:

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

Aber wenn Sie wirklich auf memcpy() aus irgendeinem Grunde zu bestehen, dann müssen Sie sicherstellen, dass die Zeichenfolge tatsächlich genügend Daten in kopiert werden. Und dann kopieren Sie einfach mit &str[0] als Zieladresse ^{& dagger;}:

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

---

^{& Dolch;} Pre-C++ 11 es gibt technisch keine Garantie, dass Strings zusammenhängend im Speicher abgelegt werden, obwohl dies in der Praxis ohnehin der Fall war.

Answer 2

Sie müssen die Größe der Zeichenfolge setzen, so dass es ein ausreichend dimensionierten Puffer sein, die Daten zu empfangen, und werfen die Konstantheit aus dem Zeiger Sie erhalten data()

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

natürlich alle Dies ist im Bereich des undefinierten Verhaltens, aber nicht weniger schön.

Answer 3

Es ist ein Hack und wie Sie falsch gesagt, aber es ist möglich, da STL garantiert, dass std::string sequenziellen Speicher hat:

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

Natürlich können Sie std::memcpy auf die gleiche Art und Weise verwenden können (I verwendet strcpy nur Kopie nullterminierten String) ...

In Ihrem Fall:

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