Как преобразовать 64-битное целое число в массив символов и обратно?

У меня возникли проблемы с преобразованием int64_t в массив char и обратно. Я не знаю, что не так с приведенным ниже кодом, это имеет для меня полный логический смысл. Код работает для a как показано, но не второе число b которое явно попадает в диапазон int64_t.

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

void int64ToChar(char mesg[], int64_t num) {
  for(int i = 0; i < 8; i++) mesg[i] = num >> (8-1-i)*8;
}

int64_t charTo64bitNum(char a[]) {
  int64_t n = 0;
  n = ((a[0] << 56) & 0xFF00000000000000U)
    | ((a[1] << 48) & 0x00FF000000000000U)
    | ((a[2] << 40) & 0x0000FF0000000000U)
    | ((a[3] << 32) & 0x000000FF00000000U)
    | ((a[4] << 24) & 0x00000000FF000000U)
    | ((a[5] << 16) & 0x0000000000FF0000U)
    | ((a[6] <<  8) & 0x000000000000FF00U)
    | ( a[7]        & 0x00000000000000FFU);
  return n;
}

int main(int argc, char *argv[]) {
  int64_t a = 123456789;
  char *aStr = new char[8];
  int64ToChar(aStr, a);
  int64_t aNum = charTo64bitNum(aStr);
  printf("aNum = %lld\n",aNum);

  int64_t b = 51544720029426255;
  char *bStr = new char[8];
  int64ToChar(bStr, b);
  int64_t bNum = charTo64bitNum(bStr);
  printf("bNum = %lld\n",bNum);
  return 0;
}

выход

aNum = 123456789
bNum = 71777215744221775

Код также дает два предупреждения, которые я не знаю, как избавиться.

warning: integer constant is too large for ‘unsigned long type
warning: left shift count >= width of type

Ответ 1

Это довольно просто, проблема в том, что вы смещаете биты в массиве char, но размер файла a[i] равен 4 байрам (upcast to int), поэтому ваш сдвиг просто переходит в диапазон. Попробуйте заменить это в своем коде:

int64_t charTo64bitNum(char a[]) {
  int64_t n = 0;
  n = (((int64_t)a[0] << 56) & 0xFF00000000000000U)
    | (((int64_t)a[1] << 48) & 0x00FF000000000000U)
    | (((int64_t)a[2] << 40) & 0x0000FF0000000000U)
    | (((int64_t)a[3] << 32) & 0x000000FF00000000U)
    | ((a[4] << 24) & 0x00000000FF000000U)
    | ((a[5] << 16) & 0x0000000000FF0000U)
    | ((a[6] <<  8) & 0x000000000000FF00U)
    | (a[7]        & 0x00000000000000FFU);
  return n;
}

Таким образом вы передадите char на 64-битный номер перед выполнением смены, и вы не пройдете диапазон. Вы получите правильные результаты:

entity:Dev jack$ ./a.out 
aNum = 123456789
bNum = 51544720029426255

Просто боковое примечание, я думаю, что это тоже сработает хорошо, если вы не должны заглядывать в массив символов:

#include <string.h>

void int64ToChar(char a[], int64_t n) {
  memcpy(a, &n, 8);
}

int64_t charTo64bitNum(char a[]) {
  int64_t n = 0;
  memcpy(&n, a, 8);
  return n;
}

Ответ 2

void int64ToChar(char mesg[], int64_t num) {
    *(int64_t *)mesg = num; //or *(int64_t *)mesg = htonl(num);

}

Ответ 3

Вы на 32-битной машине? IIRC Я считаю, что суффикс U означает только "unsigned int" или "unsigned long", оба из которых являются 32 битами на 32-битной машине. Я думаю, что вам нужен "беззнаковый длинный" (64-битный) литерал в ваших смещениях бит или 0xFF00000000000000ULL

http://en.kioskea.net/faq/978-c-language-handling-64-bit-integers#unsigned-64-bit-integer

Ответ 4

В charTo64bitNum вам нужно отбросить символ до 64 бит, прежде чем переносить его:

(((int64_t)a[0] << 56) & 0xFF00000000000000U)