Ответ 1
Вы можете выполнить отправку времени компиляции по типу выражения с помощью оператора _Generic. Обратите внимание, что это часть основного языка C, а не макросов препроцессора.
int x = 0;
_Generic(x, int: invoke_int,
float: invoke_float,
double: invoke_double)(x); //calls invoke_int with x
Выражение, которое вы даете в качестве первого аргумента для _Generic, используется только для его типа во время компиляции для выбора значения для встроенного (в данном случае функции для передачи переменной времени выполнения).
_Generic предназначен только для использования с одним параметром, и, как следствие, большинство примеров показывают, как перегружать функции одним аргументом. Вы могли бы задействовать несколько сложных метапрограммирования, чтобы создать глубоко вложенные деревья _Generic, которые пробивают себе путь через все переданные аргументы, но здесь можно сделать гораздо более простой способ перегрузить функцию несколькими аргументами нескольких типов:
#include <stdlib.h>
#include <stdio.h>
// specialized definitions
void overload_1(int a, int b, int c) {
printf("all ints (%d, %d, %d)\n", a, b, c);
}
void overload_2(int a, char * b, int c) {
printf("b is a string (%d, %s, %d)\n", a, b, c);
}
void overload_3(char * a, int b, char * c) {
printf("a and c are strings (%s, %d, %s)\n", a, b, c);
}
void static_error(int l) { printf("error with overload on %d\n", l); exit(1); }
// type indices
enum ARG_TYPE {
INT = 0, CHAR_P
};
// get the ID of a specialization by the list of arg types
static inline int get_overload_id(int ac, int av[]) {
return (ac == 3 && av[0] == INT && av[1] == INT && av[2] == INT) ? 1
: (ac == 3 && av[0] == INT && av[1] == CHAR_P && av[2] == INT) ? 2
: (ac == 3 && av[0] == CHAR_P && av[1] == INT && av[2] == CHAR_P) ? 3
: -1 //error
;
}
// overloaded definition
#define overload(...) overload_ex(get_overload_id(M_NARGS(__VA_ARGS__), (int[]){ M_FOR_EACH(GET_ARG_TYPE, __VA_ARGS__) }), __VA_ARGS__)
#define overload_ex(getID, ...) \
((getID == 1) ? overload_1(GET_ARG(0, INT, __VA_ARGS__), GET_ARG(1, INT, __VA_ARGS__), GET_ARG(2, INT, __VA_ARGS__)) \
:(getID == 2) ? overload_2(GET_ARG(0, INT, __VA_ARGS__), GET_ARG(1, CHAR_P, __VA_ARGS__), GET_ARG(2, INT, __VA_ARGS__)) \
:(getID == 3) ? overload_3(GET_ARG(0, CHAR_P, __VA_ARGS__), GET_ARG(1, INT, __VA_ARGS__), GET_ARG(2, CHAR_P, __VA_ARGS__)) \
:static_error(__LINE__))
#define GET_ARG_TYPE(A) _Generic(((void)0, (A)), int: INT, char*: CHAR_P),
#define GET_ARG(N, T, ...) GET_ARG_DEFAULT_##T(M_GET_ELEM(N, __VA_ARGS__,0,0,0,0,0,0,0,0,0,0,0,0,0))
#define GET_ARG_DEFAULT_INT(A) _Generic((A), int: (A), default: 0)
#define GET_ARG_DEFAULT_CHAR_P(A) _Generic(((void)0, (A)), char*: (A), default: NULL)
// metaprogramming utility macros (not directly related to this
#define M_NARGS(...) M_NARGS_(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define M_NARGS_(_10, _9, _8, _7, _6, _5, _4, _3, _2, _1, N, ...) N
#define M_CONC(A, B) M_CONC_(A, B)
#define M_CONC_(A, B) A##B
#define M_FOR_EACH(ACTN, ...) M_CONC(M_FOR_EACH_, M_NARGS(__VA_ARGS__)) (ACTN, __VA_ARGS__)
#define M_FOR_EACH_0(ACTN, E) E
#define M_FOR_EACH_1(ACTN, E) ACTN(E)
#define M_FOR_EACH_2(ACTN, E, ...) ACTN(E) M_FOR_EACH_1(ACTN, __VA_ARGS__)
#define M_FOR_EACH_3(ACTN, E, ...) ACTN(E) M_FOR_EACH_2(ACTN, __VA_ARGS__)
#define M_FOR_EACH_4(ACTN, E, ...) ACTN(E) M_FOR_EACH_3(ACTN, __VA_ARGS__)
#define M_FOR_EACH_5(ACTN, E, ...) ACTN(E) M_FOR_EACH_4(ACTN, __VA_ARGS__)
#define M_GET_ELEM(N, ...) M_CONC(M_GET_ELEM_, N)(__VA_ARGS__)
#define M_GET_ELEM_0(_0, ...) _0
#define M_GET_ELEM_1(_0, _1, ...) _1
#define M_GET_ELEM_2(_0, _1, _2, ...) _2
#define M_GET_ELEM_3(_0, _1, _2, _3, ...) _3
#define M_GET_ELEM_4(_0, _1, _2, _3, _4, ...) _4
#define M_GET_ELEM_5(_0, _1, _2, _3, _4, _5, ...) _5
// (end of utility stuff)
int main(void) {
overload(1, 2, 3); // prints "all ints (1, 2, 3)"
overload(1, "two", 3); // prints "b is a string (1, two, 3)"
overload("one", 2, "three"); // prints "a and c are strings (one, 2, three)"
}
(M_NARGS, M_FOR_EACH и M_GET_ELEM являются макросами утилиты... вы можете расширить их для большего удобства, но они напрямую не связаны с этим.)
Как это работает, нужно построить большое тернарное операторное выражение, содержащее всевозможные специализации для функции. Мы используем макрос GET_ARG для каждого аргумента, переданного специализации, чтобы выбрать с помощью _Generic указать фактический аргумент (если это правильный тип для этой ветки) или подходящую замену по умолчанию (если это неверно, и в этом случае он просто не будет использоваться). _Generic также отображается по всем аргументам с помощью M_FOR_EACH для построения массива "runtime" целых чисел типа. Этот массив, а также количество аргументов передается в get_overload_id, чтобы получить идентификатор целочисленной функции, которую мы действительно хотим вызвать, для использования в качестве управляющего выражения в большом тройном выражении.
Несмотря на использование конструктов C уровня времени выполнения (большой тройной со всеми вариантами, диспетчерская функция для его контроля), на самом деле это не имеет реальной стоимости исполнения: поскольку аргументы функции отправки являются постоянными, и это само по себе static inline, GCC (и, предположительно, любой другой наполовину достойный компилятор) может полностью встроить его и оптимизировать все неиспользуемые ветки большого тройника, оставив только ту специализацию, которую мы действительно хотим в сгенерированной сборке (вы можете скомпилировать с помощью gcc -S и посмотрите, что это так). Это фактически полностью компиляция.