Umwandlung einer C byte-array in einen long long

Ich habe eine 8-byte-array in meiner Anwendung mit diesen Daten:

00000133339e36a2

Dieser Daten stellt eine lange (auf der Plattform die Daten, die geschrieben wurde, auf einem Mac wäre dies eine sehr, sehr lange) mit dem Wert von

1319420966562

In der tatsächlichen Anwendung dies ist eine halb-randomisierte Satz von Daten, so dass die Anzahl immer anders sein wird. Daher brauche ich zum konvertieren des byte-array in eine druckbare lange.

Habe ich versucht, Gießen Sie die Daten direkt in eine lange, lange, aber ich kam mit 

1305392

soll, wo ich gesehen habe das oben angegebene Nummer.

Für diejenigen von Euch mit mehr Erfahrung in C byte manipulation, als ich es tun würde, wie ich richtig konvertieren eines byte-array in einen long long?

EDIT: Seltsam, alle Ihre Lösungen halten die Ausgabe der gleichen Anzahl: 866006690. Das ist die Dezimalzahl, die letzten vier bytes der Daten.

InformationsquelleAutor voidzm | 2011-10-24
  1. 3

    Diese scheint eine der (seltenen) Situationen, in denen eine Gewerkschaft hilfreich ist:

    union number
{
    char charNum[16];
    long long longNum;
};
    • Ausgezeichnete Lösung, habe nicht daran gedacht.
    InformationsquelleAutor BlackBear
  2. 3
    union le_long_long_array_u
{
  uint8_t byte[8];
  uint64_t longlong;
} le_long_long_array;

    Kopieren (oder einfach) le_long_long_array.byte[] für die array;
    Lesen zurück le_long_long_array.longlong

    Beispiel:

    fill_array(&le_long_long_array.byte[0]);
return le_long_long_array.longlong;

    Fuller Beispiel:

    #include <stdint.h>
#include <stdio.h>

union le_long_long_array_u
{
  uint8_t byte[8];
  uint64_t longlong;
} le_long_long_array;

static uint8_t hex2int (char c)
{
    return (c >= '0' && c <= '9') 
            ? (uint8_t )(c  - '0')
            : ((c >= 'a' && c <= 'f') 
                ? (uint8_t )(c  - 'a')
                : ((c >= 'A' && c <= 'F') 
                    ? (uint8_t )(c  - 'A')
                    : 0));
}

int main (int argc, char **argv)
{
    if (argc == 2)
    {
        int i;
        for (i = 0; i <= 7; i++)
        {
            char *str = argv[1];

            if (str[2*i] == '\0' || str[2*i+1] == '\0')
            {
                printf("Got short string.\n");
                return 1;
            }

            le_long_long_array.byte[i] = (hex2int(str[2*i]) << 4) + hex2int(str[2*i+1]);
        }
        printf("Got %lld\n", le_long_long_array.longlong);
    }
    else
    {
        printf("Got %d args wanted 1.\n", argc - 1);
        return 1;
    }
    return 0;
}

    Produziert:

    e e$ gcc -c un.c
e e$ gcc -o un un.o
e e$ ./un 0100000000000000
Got 1
e e$ ./un 0101000000000000
Got 257
e e$ ./un a23639333301000000
Got 1319414347266
e e$

    als Sie erwarten würden, für little-endian-Daten.

    • Beachten Sie endianness, aber ich weiß nicht, wie groß ein Anliegen, dass wirklich ist.
    • Ja, ich hab das Präfix le_ denn der Mac ist Little Endian, da x86-obwohl in diesem Fall die Verantwortung ist wirklich auf den Benutzer, der die Struktur und füllen Sie das byte-array in eine endian angemessenen Art und Weise.
    • Ich habe versucht, und endete mit der Zahl 866006690. Irgendwelche Ideen?
    • Siehe fuller Beispiel oben
    InformationsquelleAutor Doug Currie
  3. 2

    Je nach gewünschter endianness, so etwas wie dies funktionieren würde:

    int i;
char inArray[8] = { 0x00,0x00,0x01,0x33,0x33,0x9e,0x36,0xa2 };
long long outLong = 0;

for(i=0; i<8; i++)
    outLong |= ( (long long)inArray[i]) << (i*8) );
    • &= ist nicht der richtige operator hier. und das array enthält hexadezimal-Werte.
    • Ja, bemerkte ich, dass die Betreiber und fixiert es. Und es scheint, ich habe falsch interpretiert die Frage. Die Festsetzung, dass als gut, vielen Dank.
    InformationsquelleAutor Chriszuma
  4. 1
    long long num = 0;
for(int i = 0; i < 8; i++) {
    num = (num << 8) | byte_array[i];
}

    Vorausgesetzt, Sie sind gespeichert (big-endian.

    InformationsquelleAutor Kevin
  5. 1

    Große Frage! Und Super Antworten! Werfen Sie einen cent:

    //Getting stuff "in"
unsigned long long ll1 = 1319420966562;
unsigned char * c = reinterpret_cast<unsigned char *>( &ll1 );

//Getting stuff "out"
unsigned long long ll2;
memcpy( &ll2, c, 8 );

    ll2 jetzt gleich ll1.

    Muss ich admin, allerdings mag ich die union Beispiele besser. 🙂

    InformationsquelleAutor Robin
  6. 0

    Vielleicht eine Zeiger-notation?

    uint8_t Array[8] = { 0x00,0x00,0x01,0x33,0x33,0x9e,0x36,0xa2 };
uint32_t *Long = Array;

    Oder, wenn möglich, 

    *((uint32_t*)Array)
    InformationsquelleAutor Roger
Schreibe einen Kommentar