Konvertieren von 24 bit integer (2er Komplement) auf 32-bit-integer in C++

Datenfile.bin ist eine Binärdatei mit 6-byte-records. Die ersten 3
bytes jedes Datensatzes enthalten die Breite und die letzten 3 bytes enthalten
der Längengrad. Jeder 24-bit-Wert repräsentiert Bogenmaß multipliziert mit
0X1FFFFF

Dies ist eine Aufgabe, die ich gearbeitet habe. Ich habe nicht getan, C++, im Jahre so, wobei mir seine Weg länger, als ich dachte, es würde -_-. Nach googeln um ich sah diese algorthim das machte Sinn für mich.

int interpret24bitAsInt32(byte[] byteArray) {     
 int newInt = (  
     ((0xFF & byteArray[0]) << 16) |  
     ((0xFF & byteArray[1]) << 8) |   
     (0xFF & byteArray[2])  
   );  
 if ((newInt & 0x00800000) > 0) {  
   newInt |= 0xFF000000;  
 } else {  
   newInt &= 0x00FFFFFF;  
 }  
return newInt;  
}

Das problem ist ein syntax Problem bin ich eingeschränkt zu arbeiten, die durch die Art und Weise hatte der andere Typ programmiert diese. Ich bin nicht verstehen, wie ich speichern kann, die der CHAR "Daten" in einen INT. Würde es nicht mehr Sinn machen, wenn "Daten" wurde ein Array? Seit seinem Empfang 24 Ganzzahlen von gespeicherten Informationen in ein BYTE.

double BinaryFile::from24bitToDouble(char *data) {
    int32_t iValue;

    //****************************
    //Start code implementation
    //Task: Fill iValue with the 24bit integer located at data.
    //The first byte is the LSB.
    //****************************
//iValue += 
    //****************************
    //End code implementation
    //****************************
    return static_cast<double>(iValue) / FACTOR;
}

bool BinaryFile::readNext(DataRecord &record)
{
    const size_t RECORD_SIZE = 6;
    char buffer[RECORD_SIZE];
    m_ifs.read(buffer,RECORD_SIZE);
    if (m_ifs) {
        record.latitude = toDegrees(from24bitToDouble(&buffer[0]));
        record.longitude = toDegrees(from24bitToDouble(&buffer[3]));
        return true;
    }
    return false;
}

double BinaryFile::toDegrees(double radians) const
{
    static const double PI = 3.1415926535897932384626433832795;
    return radians * 180.0 / PI;
}

Ich Schätze jede Hilfe oder Hinweise, auch wenn Sie nicht verstehen, ein Hinweis oder Tipp wird mir helfen, eine Menge. Ich muss nur mit jemandem reden.

InformationsquelleAutor Hulio-G | 2016-03-08

8

Ich bin nicht verstehen, wie ich speichern kann, die der CHAR "Daten" in einen INT.

Seit char ist ein numerischer Typ ist, ist es kein problem, die Kombination von Ihnen in einem einzigen int.

Seit Eingang 24 Ganzzahlen von gespeicherten Informationen in ein BYTE -

Es 24 bits, nicht bytes, so gibt es nur drei integer-Werte, die kombiniert werden müssen.

Einen einfacheren Weg, produzieren das gleiche Ergebnis ohne Verwendung von Bedingungen ist wie folgt:
```
int interpret24bitAsInt32(byte[] byteArray) {     
    return (  
        (byteArray[0] << 24)
    |   (byteArray[1] << 16)
    |   (byteArray[2] << 8)
    ) >> 8;  
}
```
Die Idee ist das speichern von drei bytes geliefert als ein Eingang zu der oberen drei bytes eines vier-byte -int, und dann verschieben Sie es nach unten durch ein byte. Auf diese Weise würde das Programm sign-erweitern Sie Ihre Nummer automatisch, die Vermeidung bedingte Ausführung.

Hinweis: Dieser code ist nicht portabel, weil es annimmt, dass 32-bit-integer-Größe. Um es den mobilen Einsatz <cstdint> Typen:
```
int32_t interpret24bitAsInt32(int8_t[] byteArray) {
    return (  
        (byteArray[0] << 24)
    |   (byteArray[1] << 16)
    |   (byteArray[2] << 8)
    ) >> 8; 
}
```
Es wird auch davon ausgegangen, dass das höchstwertige byte der 24-bit-Zahl gespeichert ist, in das erste element der byteArray, dann kommt das mittlere element, und zuletzt das niederwertigste byte.
- Hoppla, ich bin ja kopieren-einfügen mehr als notwendig war. Danke!
InformationsquelleAutor dasblinkenlight
0

Als ein unsigned char gecastet in eine int die höherwertigen bits werden mit 0 aufgefüllt ist

Wenn ein signed char ist gegossen, um eine umgewandelte int, das Vorzeichen-bit erweitert.
ie:
```
int x;
char y;
unsigned char z;
y=0xFF
z=0xFF
x=y;
/*x will be 0xFFFFFFFF*/
x=z;
/*x will be 0x000000FF*/
```
So, Ihr Algorithmus, verwendet 0xFF als Maske zu entfernen, C' sign extension, ie
```
0xFF == 0x000000FF
0xABCDEF10 & 0x000000FF == 0x00000010
```
Dann verwendet bit-Verschiebungen und logischen ands setzen die bits in der richtigen Stelle.

Schließlich prüft das höchstwertige bit (newInt & 0x00800000) > 0 zu entscheiden, wenn der Abschluss mit 0 oder diejenigen, die die höchste byte.

InformationsquelleAutor xvan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.