Erhalten eines int32_t oder int64_t Wert aus einer char Array

Question

Eine Operation I mir durchführen müssen erfordert eine int32_t Wert und 2 int64_t Werte aus einer char Array erhalten

die ersten 4 Bytes des char Array enthalten den int32 Wert, die nächsten 8 Bytes enthalten den ersten int64_t-Wert, die nächsten 8 Bytes enthalten den zweiten. Ich kann nicht herausfinden, wie ich zu diesen Werten komme. Ich habe versucht;

int32_t firstValue = (int32_t)charArray[0]; 
int64_t firstValue = (int64_t)charArray[1]; 
int64_t firstValue = (int64_t)charArray[3]; 

int32_t *firstArray = reinterpet_cast<int32_t*>(charArray); 
int32_t num = firstArray[0]; 
int64_t *secondArray = reinterpet_cast<int64_t*>(charArray); 
int64_t secondNum = secondArray[0]; 

Ich greife nur an Strohhalmen. Jede Hilfe willkommen

Answer 1

quick and dirty Lösung:

int32_t value1 = *(int32_t*)(charArray + 0); 
int64_t value2 = *(int64_t*)(charArray + 4); 
int64_t value3 = *(int64_t*)(charArray + 12); 

Beachten Sie, dass dies möglicherweise dazu führen könnte, falsch ausgerichtete Speicherzugriffe. Also funktioniert es vielleicht nicht immer.

---

Eine robustere Lösung, die nicht streng-Aliasing nicht verletzt und Ausrichtungsprobleme nicht haben:

int32_t value1; 
int64_t value2; 
int64_t value3; 

memcpy(&value1,charArray + 0,sizeof(int32_t)); 
memcpy(&value2,charArray + 4,sizeof(int64_t)); 
memcpy(&value3,charArray + 12,sizeof(int64_t)); 

Answer 2

wenn charArray ist ein 1 Byte char Typ, dann müssen Sie 4 verwenden und 12 für 2. und 3. Werte

Answer 3

versuchen, diese

typedef struct { 
    int32_t firstValue; 
    int64_t secondValue; 
    int64_t thirdValue; 
} hd; 

hd* p = reinterpret_cast<hd*>(charArray); 

Jetzt können Sie auf die Werte z. p-> firstValue

EDIT: stellen Sie sicher, dass die Struktur an Byte-Grenzen gepackt ist, z. Mit Visual Studio schreiben Sie #pragma pack(1) vor der Struktur

Answer 4

Um Ausrichtungsfragen zu vermeiden, ist die ideale Lösung, die Bytes aus dem Puffer in die Zielobjekte zu kopieren. Um dies zu tun, können Sie einige hilfreiche Dienstprogramme verwenden:

typedef unsigned char const* byte_iterator; 

template <typename T> 
byte_iterator begin_bytes(T& x) 
{ 
    return reinterpret_cast<byte_iterator>(&x); 
} 

template <typename T> 
byte_iterator end_bytes(T& x) 
{ 
    return reinterpret_cast<byte_iterator>(&x + 1); 
} 

template <typename T> 
T safe_reinterpret_as(byte_iterator const it) 
{ 
    T o; 
    std::copy(it, it + sizeof(T), ::begin_bytes(o)); 
    return o; 
} 

Dann wird Ihr Problem ist einfach:

int32_t firstValue = safe_reinterpret_as<int32_t>(charArray); 
int64_t secondValue = safe_reinterpret_as<int64_t>(charArray + 4); 
int64_t thirdValue = safe_reinterpret_as<int64_t>(charArray + 12);