Понимание _Generic C11

Если uint64_t является определением типа, скажем, unsigned long long int, и они оба у меня есть в каком-то выражении _Generic, будет ли это противоречить «Никакие две универсальные ассоциации в одном и том же общем выборе не должны указывать совместимые типы»?

Да.

Если да, то какого поведения мне следует ожидать? Компиляция не удалась? Неопределенное поведение? Диагностика?

Появится диагностическое сообщение, и большинство компиляторов откажутся компилировать программу.

Есть ли что-то, что потенциально может пойти не так в приведенном выше выражении _Generic,

Нет, не так, как сейчас написано.

особенно если я добавлю к нему целочисленные типы фиксированной ширины из stdint.h?

Да, тогда у вас возникнут проблемы, поскольку вы укажете один и тот же тип более одного раза, и вы получите диагностические сообщения, и программа, скорее всего, не сможет скомпилироваться.

@Тед Люнгмо хорошо отвечает на явные вопросы ОП.

Тем не менее, остается без ответа подразумеваемый вопрос: как использовать _Generic для управления кодом, когда uint64_t не соответствует ни одному стандартному типу?

Используйте больше уровней

На верхнем уровне map() добавьте default:, который управляет кодом между uint64_t, uint32_t и т. д. Это можно даже перенести на дополнительные уровни для size_t, uintmax_t, которые могут конфликтовать с предыдущими типами.

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

int map_uc(int, unsigned char*, int);
int map_usi(int, unsigned short*, int);
int map_ui(int, unsigned*, int);
int map_uli(int, unsigned long*, int);
int map_ulli(int, unsigned long long*, int);
int map_u8(int, uint8_t*, int);
int map_u16(int, uint16_t*, int);
int map_u32(int, uint32_t*, int);
int map_u64(int, uint64_t*, int);

#define map2(iter) _Generic (*(iter),   \
    uint8_t: map_u8,  \
    uint16_t: map_u16,  \
    uint32_t: map_u32,  \
    uint64_t: map_u64    \
    )

#define map(count, iter, func) _Generic (*(iter),   \
    unsigned char: map_uc,  \
    unsigned short int: map_usi,    \
    unsigned int: map_ui,   \
    unsigned long int: map_uli, \
    unsigned long long int: map_ulli,   \
    default: map2(iter)   \
    ) ((count), (iter), (func))

int main(void) {
  uint64_t sz = 123;
  uint64_t *xx = &sz;
  printf("%d\n", map(0, xx, 0));
  return 0;
}

Что касается целочисленных типов, _Generic и stdint.h, похоже, существует несколько заблуждений.

• _Generic не продвигает по типу первый элемент в списке ассоциаций (но проводит его через «преобразование lvalue», что означает отбрасывание квалификаторов типа).

  Однако имейте в виду, что если вы передадите ему выражение, то это выражение само по себе может содержать неявные повышения типа. Например _Generic((signed char){}, ... приведет к signed char но _Generic(+(signed char){}, ... приведет к int. Что, конечно, не имеет ничего общего с _Generic само по себе.

• Для стандартных «примитивных» целочисленных типов данных C все они будут уникальными типами по отношению друг к другу: signed char, short, int, long и long long. Несмотря на то, что некоторые из них могут иметь одинаковый размер, они будут иметь разный рейтинг конверсии, поэтому _Generic следует рассматривать их все как отдельные типы.

• Для типов stdint.h они будут реализованы как typedef, соответствующие «примитивным» типам данных (C17 7.20 §4), что означает, что вы не можете иметь, например, int и int16_t в одном и том же списке _Generic ассоциаций, при переносимости. Они могут быть или не быть одного и того же типа.

• Любой компилятор C обязательно предоставляет int8_t, int16_t, int32_t и int64_t, если соответствующий тип существует на аппаратном уровне целевой системы. Это типы точной ширины, поэтому все они являются уникальными типами по отношению друг к другу, учитывая, что тип существует в конкретной системе.

• Однако обязательные типы int_leastn_t и int_fastn_t могут быть дубликатами друг друга.

Краткое содержание:

Хорошо определяемый и 100% портативный без поднятой диагностики:

_Generic((x), 
  signed char: 0,
  short: 0,
  int: 0,
  long: 0,
  long long: 0)

_Generic((x), 
  int8_t:  0,
  int16_t: 0,
  int32_t: 0,
  int64_t: 0)

(Хотя малоизвестные/экзотические системы не обязательно должны предоставлять все типы точной ширины stdint.h.)