Extrahieren

Question

I einen integralen Typen eines Byte-Array, wie das hier schreibt:

unsigned char Data[10]; // Example byte array 
signed long long Integer = 1283318; // arbitrary value 
for (int i = 0; i < NumBytes; ++i) 
    Data[i] = (Integer >> (i * 8)) & 0xff; // Set the byte 

In diesem Zusammenhang NumBytes ist die Anzahl des Bytes, die tatsächlich in das Array geschrieben werden, die ich ändern kann, - manchmal werde ich eine kurze, manchmal eine int schreiben, etc. sein

In einem Testfall, wo ich weiß, NumBytes == 2, das den Integralwert abzurufen funktioniert:

signed short Integer = (Data[0] << 0) | (Data[1] << 8); 

auf dieser Basis , ICH versucht, das gleiche mit einem langen lange zu tun, es wäre für einen beliebigen ganzzahligen Typen so funktionieren:

signed long long Integer = 0; 
for (int i = 0; i < NumBytes; ++i) 
    Integer |= static_cast<signed long long>(Data[i]) << (i * 8); 

Aber dies fehlschlägt, wenn Integer < 0. ich dankbar sein würde, wenn jemand zeigen könnte, was ich bin fehlt hier. Unterbreche ich das Vorzeichen? Wie würde ich sicherstellen, dass dies auf eine tragbare Weise enthalten ist?

Prost!

Answer 1

Dies funktioniert:

#include <iostream> 

using namespace std; 

int main() { 
    signed short Input = -288; 
    int NumBytes = sizeof(signed long long); 

    unsigned char Data[10]; // Example byte array 
    signed long long Integer = Input; // arbitrary value 
    std::cout << Integer << std::endl; 
    for (int i = 0; i < NumBytes; ++i) 
     Data[i] = (Integer >> (i * 8)) & 0xff; // Set the byte 
    signed long long Integer2 = 0; 
    for (int i = 0; i < NumBytes; ++i) 
     Integer2 |= static_cast<signed long long>(Data[i]) << (i * 8); 
    std::cout << Integer2 << std::endl; 
    return 0; 
} 

Wenn Sie die kurze in die lange lange drehen, wie Sie in Ihrem Code haben, wird das Vorzeichen-Bit das signifikanteste Bit in der langen lange, was bedeutet, richtig zu kodieren/dekodieren es braucht die alle 8 Bytes.