How to combine two 32-bit integers into one 64-bit integer?

Solution 1:

It might be advantageous to use unsigned integers with explicit sizes in this case:

#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;
}

4294967296

Break down of (uint64_t) mostSignificantWord << 32 | leastSignificantWord

• (typename) does typecasting in C. It changes value data type to typename.

  (uint64_t) 0x00000001 -> 0x0000000000000001

• << does left shift. In C left shift on unsigned integers performs logical shift.

  0x0000000000000001 << 32 -> 0x0000000100000000

• | does 'bitwise or' (logical OR on bits of the operands).

  0b0101 | 0b1001 -> 0b1101

Solution 2:

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

Solution 3:

my take:

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 */

Another approach:

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 */

Both versions work, and they will have similar performance (the compiler will optimize the memcpy away).

The second version does not work with big-endian targets but otoh it takes the guess-work away if the constant 32 should be 32 or 32ull. Something I'm never sure when I see shifts with constants greater than 31.