Гарантированно ли (uint64_t)-1 даст 0xffffffffffffffff?

Да. См. C11 6.3.1.3 Целые числа со знаком и без знака:

1 Когда значение с целочисленным типом преобразуется в другой целочисленный тип, отличный от _Bool, если значение может быть представлено новым типом, оно не изменяется.

2 В противном случае, если новый тип не имеет знака, значение преобразуется путем многократного добавления или вычитания на единицу больше, чем максимальное значение, которое может быть представлено в новом типе, пока значение не окажется в диапазоне нового типа.⁶⁰⁾

3 В противном случае новый тип является знаковым и значение в нем не может быть представлено; либо результат определяется реализацией, либо выдается сигнал, определяемый реализацией.

⁶⁰⁾ Правила описывают арифметические действия над математическим значением, а не над значением данного типа выражения.

Применяется случай 2, поэтому -1 уменьшается по модулю 0x10000000000000000, чтобы получить 0xffffffffffffffffff.

Выражения 1 и -1 имеют тип int. При преобразовании в uint64_t применяется принцип прибавления или вычитания 2ⁿ до тех пор, пока значение не окажется в диапазоне, поэтому результатом всегда будет 2ⁿ-1, в данном случае с п=64. Следовательно, (uint64_t)-1 всегда равно 2⁶⁴-1..

Выражение (int64_t)-1 оценивается как -1, поэтому те же рассуждения применимы к выражению (uint64_t)(int64_t)-1, которое тоже всегда дает 2⁶⁴-1.

С другой стороны, (unsigned)-1 является положительным значением типа unsigned int, которое может быть 2¹⁶-1, 2³²-1, 2⁶⁴- 1 или различные другие значения в зависимости от платформы компиляции. Эти значения могут не давать 2⁶⁴-1 при преобразовании в uint64_t.

Я предполагаю, что вы пишете (uint64_t)-1 вместо -1ULL, потому что не хотите делать предположения о размере unsigned long long? Если так, то это хорошо. Однако есть альтернатива, которая еще не упоминалась (и на самом деле не отвечает на ваш вопрос), но может избавить вас от беспокойства, обходя вопрос:

Альтернатива

Хорошая привычка — всегда использовать UINT64_C(x) вместо (uint64_t)x. Это макрос, определенный в <stdint.h>, который автоматически добавляет U, UL или ULL по мере необходимости. Таким образом, UINT64_C(-1) преобразуется в -1U, -1UL или -1ULL, в зависимости от вашей цели. Это гарантированно всегда работает правильно.

Опасности приведения типов

Обратите внимание, что (uint64_t)x на самом деле вообще не работает корректно. Например,

(uint64_t)2147483648                // RISKY

генерирует предупреждение на некоторых компиляторах, потому что значение 2147483648 (2^31) слишком велико для 32-битного целого числа, а следующее даже отдаленно не работает:

(uint64_t)1000000000000000000       // RISKY

Однако, если вместо этого вы используете UINT64_C(), то все золото:

UINT64_C(2147483648)                // GOOD

UINT64_C(1000000000000000000)       // GOOD

UINT64_C(-1)                        // GOOD

Заметки:

• Суффикс _C означает «постоянный».
• В <stdint.h> есть также 8-, 16- и 32-битные версии для значений со знаком и без знака.
• Для особого случая –1 вы также можете просто написать UINT64_MAX.

Это вопрос, на который можно ответить с помощью нескольких строк кода.

#include <stdio.h>

main()
{
    int          x;
    unsigned int y;

    x = -1;
    printf("\n0x%08x", x);

    y = (unsigned int) -1;
    printf("\n0x%08x", y);

}

Запуск этого кода на компиляторе Eclipse/Microsoft C дает:

0xffffffff
0xffffffff

Аналогичная программа может показать вам, что производит uint64_t.

Наконец, если вы понимаете, как компьютеры используют числа с дополнением до 2 для сложения чисел, то вы поймете, что -1 для слов с любым количеством битов (8, 32, 64 и т. д.) всегда представляет собой все ff для каждого байта в слове/. двойное слово и др.