Ich habe ein Zählregister, das aus zwei 32-Bit-Ganzzahlen ohne Vorzeichen besteht, eine für die höheren 32 Bits des Werts (höchstwertiges Wort) und eine andere für die niedrigeren 32 Bits des Werts (niederwertiges Wort).

Was ist der beste Weg in C, um diese beiden 32-Bit-Ganzzahlen ohne Vorzeichen zu kombinieren und dann als große Zahl anzuzeigen?

Im Einzelnen:

leastSignificantWord = 4294967295; //2^32-1

printf("Counter: %u%u", mostSignificantWord,leastSignificantWord);

Dies würde gut drucken.

Wenn die Zahl auf 4294967296 erhöht wird, habe ich es so, dass das leastSignificantWord auf 0 löscht und das mostSignificantWord (anfänglich 0) jetzt 1 ist. Der gesamte Zähler sollte jetzt 4294967296 anzeigen, aber im Moment zeigt er nur 10 an, weil ich nur verkette 1 von mostSignificantWord und 0 von leastSignificantWord.

Wie soll ich 4294967296 anstelle von 10 anzeigen lassen?

Es kann von Vorteil sein, es zu verwenden ohne Vorzeichen ganze Zahlen mit explizit Größen in diesem Fall:

#include <stdio.h>
#include <inttypes.h>

int main(void) {
  uint32_t leastSignificantWord = 0;
  uint32_t mostSignificantWord = 1;
  uint64_t i = (uint64_t) mostSignificantWord << 32 | leastSignificantWord;
  printf("%" PRIu64 "\n", i);

  return 0;
}

Ausgabe

4294967296

Zusammenbruch von (uint64_t) mostSignificantWord << 32 | leastSignificantWord

• (typename) tut Typisierung in C. Es ändert den Wertdatentyp in typename.

  (uint64_t) 0x00000001 -> 0x000000000000001

• << tut Linksverschiebung. In C führt eine Linksverschiebung bei vorzeichenlosen Ganzzahlen durch logische Verschiebung.

  0x0000000000000001 << 32 -> 0x0000000100000000

• | tut ‘bitweise oder’ (logisches ODER auf Bits der Operanden).

  0b0101 | 0b1001 -> 0b1101

long long val = (long long) mostSignificantWord << 32 | leastSignificantWord;
printf( "%lli", val );

meine aufnahme:

unsigned int low = <SOME-32-BIT-CONSTRANT>
unsigned int high = <SOME-32-BIT-CONSTANT>

unsigned long long data64;

data64 = (unsigned long long) high << 32 | low;

printf ("%llx\n", data64); /* hexadecimal output */
printf ("%lld\n", data64); /* decimal output */

Ein anderer Ansatz:

unsigned int low = <SOME-32-BIT-CONSTRANT>
unsigned int high = <SOME-32-BIT-CONSTANT>

unsigned long long data64;
unsigned char * ptr = (unsigned char *) &data;

memcpy (ptr+0, &low, 4);
memcpy (ptr+4, &high, 4);

printf ("%llx\n", data64); /* hexadecimal output */
printf ("%lld\n", data64); /* decimal output */

Beide Versionen funktionieren und haben eine ähnliche Leistung (der Compiler optimiert die memcpy weg).

Die zweite Version arbeitet nicht mit Big-Endian-Zielen, aber otoh, es nimmt dem Rätselraten, ob die Konstante 32 32 oder 32ull sein soll, ein Ende. Etwas, bei dem ich mir nie sicher bin, wenn ich Verschiebungen mit Konstanten größer als 31 sehe.

Es gibt eine andere Möglichkeit, Arrays und Zeiger zu verwenden:

#include <stdio.h>
#include <inttypes.h>

int main(void) {
    // Two uint32_t to one uint64_t
    uint32_t val1[2] = {1000, 90000};
    uint64_t *val1_u64_ptr = (uint64_t*)val1; //intermediate pointer cast to avoid Wstrict-aliasing warnings
    uint64_t val2 = *val1_u64_ptr;
    printf("val2: %" PRIu64 "\n", val2);
    // val2: 386547056641000


    // back to uint32_t array from uint64_t
    uint64_t val3 = 386547056641000ull;
    uint32_t *val4 = (uint32_t*)&val3;
    printf("val4: %" PRIu32 ", %" PRIu32 "\n", val4[0], val4[1]);
    // val4: 1000, 90000
    
    return 0;
}

Dieser Code ist für mich viel einfacher zu verstehen und zu lesen. Sie erstellen nur einen zusammenhängenden Raum im Speicher mit zwei 32-bit unsigned int und dann wird dieser selbe Speicherplatz als Single gelesen 64-bit unsigned int Wert und umgekehrt. Es sind keine Operationen beteiligt, nur der Speicher wird als unterschiedliche Typen gelesen.

BEARBEITEN

Ich habe vergessen zu erwähnen, dass dies großartig ist, wenn Sie bereits eine haben 64-bit array von irgendwo lesen dann könnte man alles problemlos nachlesen 32-bit array Paare:

#include <stdio.h>
#include <inttypes.h>

int main() {
    uint64_t array64[] = {
        386547056641000ull,
        93929935171414ull,
        186655006591110ull,
        73141496240875ull,
        161460097995400ull,
        351282298325439ull,
        97310615654411ull,
        104561732955680ull,
        383587691986172ull,
        386547056641000ull
    };

    int n_items = sizeof(array64) / sizeof(array64[0]);
    
    uint32_t* array32 = (uint32_t*)&array64;
    for (int ii = 0; ii < n_items * 2; ii += 2) {
        printf("[%" PRIu32 ", %" PRIu32 "]\n", array32[ii], array32[ii + 1]);
    }

    return 0;
}

Ausgabe:

[1000, 90000]
[3295375190, 21869]
[22874246, 43459]
[2498157291, 17029]
[3687404168, 37592]
[1218152895, 81789]
[3836596235, 22656]
[754134560, 24345]
[4162780412, 89310]
[1000, 90000]

Union-Struktur verwenden

Noch besser und lesbarer wäre es, eine Struct Union wie von https://stackoverflow.com/a/2810339/2548351 zu verwenden:

#include <stdio.h>
#include <inttypes.h>

typedef union {
  int64_t big;
  struct {
    int32_t x;
    int32_t y;
  };
} xy_t;

int main() {
    // initialize from 64-bit
    xy_t value = {386547056641000ull};
    printf("[%" PRIu32 ",%" PRIu32 "]\n", value.x, value.y);
    // [1000, 90000]
    
    // initialize as two 32-bit
    xy_t value2 = {.x = 1000, .y = 90000};
    printf("%" PRIu64, value.big);
    // 386547056641000

    return 0;
}

Anstatt zu versuchen, Dezimalzahlen zu drucken, drucke ich oft in Hex.

Daher …

printf ("0x%x%08x\n", upper32, lower32);

Alternativ können Sie je nach Architektur, Plattform und Compiler manchmal mit etwas davonkommen wie …

printf ("%lld\n", lower32, upper32);

oder

printf ("%lld\n", upper32, lower32);

Diese alternative Methode ist jedoch sehr maschinenabhängig (Endian-ness sowie 64 vs. 32 Bit, …) und wird im Allgemeinen nicht empfohlen.

Hoffe das hilft.

Dieser Code funktioniert, wenn sowohl “upper32” als auch “lower32” negativ sind:

data64 = ((LONGLONG)upper32<< 32) | ((LONGLONG)lower32& 0xffffffff);

Sie könnten dies tun, indem Sie die 32-Bit-Werte an die richtigen Stellen im Speicher schreiben:

unsigned long int data64;
data64=lowerword
*(&((unsigned int)data64)+1)=upperword;

Dies ist jedoch maschinenabhängig, zum Beispiel funktioniert es auf Big-Endian-Prozessoren nicht korrekt.