Произвольное число аргументов любых типов на C11 и выше с помощью _Generic и variadic макросов

Функция print на Си, принимающая любые аргументы в любом количестве

О себе

Я сам программист на C++, вернее я только начинающий, без коммерческого опыта. Изначально я познакомился с языком Си, а C++ открыл как мощное расширение языка C. В нем на мой взгляд добавлены те необходимые полезные вещи, которых нет в C (перегрузка функций, классы, пространства имен и др), при этом эти вещи отлично расширяют философию языка

Задумка

Я узнал что в C стандарта 2011 года добавили небольшую возможность «перегрузки» функций с помощью макроса. (Generic selection) Мне, очень интересно стало написать какую-нибудь функцию, которая максимально использовала бы эту возможность

Задумка: написать (макро) функцию print, которая выводит через пробел все переданные в нее аргументы. Звучит невероятно для Си, где обычно указывают тип принимаемого аргумента одной буквой в имени, и явно указывают число переданных аргументов. Но с джейнериками из C11 это возможно

Простой пример с одним аргументом

Ввиду в суть работы этой перегрузки по типу на простом примере с одним аргументом

Напишем три функции print(x) для типов int, float и char* (cstring):

void print_int(int x) {printf("%d ", x); }  void print_float(float x) {printf("%.4f ", x); } void print_string(char* x) {printf("%s ", x); }

С помощью данного макроса соединим из под одним именем print:

#define print(x) _Generic((X),    int: print_int,    float: print_float,    char*: print_string)(x)

В итоге получим, что запись print("hi") вызывает print_string("hi"), print(5.5) вызывает print_float(5.5) и так далее

После обработки препроцессором запись print("hi") превратится в _Generic(("hi"), int: print_int, float: print_float, char*: print_string)("hi"), и компилятор в зависимости от типа первого аргумента выберет имя функции, которую надо подставить вместо всего выражения _Generic(...)

Неопределенное число однородных аргументов

С помощью макросов также можно передавать неопределенное число аргументов без явного указания их числа. Покажу на примере для функции print_int

void print_int(int n, ...) {   va_list argptr;   va_start(argptr, n);   int x;   for (int i = 0; i < n; i++)   {     x = va_arg(argptr, int);     printf("%d ", x);   }   va_end(argptr); }

С помощью макроса, который я любезно скопипастил из гугла 🙂 можем вывести число аргументов n, и передать его в функцию первым аргументом

#ifndef PP_NARG /*       The PP_NARG macro returns the number of arguments that have been    passed to it.     https://groups.google.com/g/comp.std.c/c/d-6Mj5Lko_s  /  #define PP_NARG(...)     PP_NARG_(VA_ARGS,PP_RSEQ_N()) #define PP_NARG_(...)     PP_ARG_N(VA_ARGS) #define PP_ARG_N( _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, _61,_62,_63, N, ...) N #define PP_RSEQ_N() 63,62,61,60, 59,58,57,56,55,54,53,52,51,50, 49,48,47,46,45,44,43,42,41,40, 39,38,37,36,35,34,33,32,31,30, 29,28,27,26,25,24,23,22,21,20, 19,18,17,16,15,14,13,12,11,10, 9,8,7,6,5,4,3,2,1,0 #endif

#define print(...)    print_int(PP_NARG(VA_ARGS), VA_ARGS)

Примечание: VA_ARGS содержит в себе аргументы, которые попали в ...

Соответственно для джейнериков, если все аргументы одного типа, мы должны написать

#define function(x, ...) Generic((x),    int: function_int,  float: function_float,  char*: function_string)(PP_NARG(VA_ARGS) + 1, x, VA_ARGS)

В итоге получим функцию function, которая обрабатывает неопределенное число однотипных аргументов. Я написал function, а не print, так как для нашей функции это точно не подойдет. Однако если вам известно, что все аргументы одного и того же типа, то такой способ будет намного проще, чем когда любой аргумент любого типа

Неопределенное число аргументов любого типа

I. Хранение информации о типах

Мы создадим универсальную функцию вида (синтаксис вольный) hidden_print(sep, n, x1, x2, x3, ...), которая в зависимости от типа следующей переменной xi выполняет нужный printf. Для любой другой реализации можно вызывать нужную функцию с уже известным типом

Для определенности максимальное число аргументов будет 12. Для print‘а этого достаточно.

Для хранения информации о типах аргументов буду использовать массив cool_hidden_types[12], индекс cool_hidden_last, куда надо добавить следущий элемент cool_hidden_add_int, cool_hidden_add_float и т.д. для каждого типа, которые добавляют в массив значение о типах. Всего наша функция будет поддерживать 7 типов: int, char*, float, double, char (?), uint, long

Значения о типах я решил определить с помощью #define, хотя в си есть и enum. Но раз уж тут почти весь код на макросах, то гулять так гулять!

#define COOL_HIDDEN_INT 0 #define COOL_HIDDEN_STRING 1 #define COOL_HIDDEN_FLOAT 2 #define COOL_HIDDEN_DOUBLE 3 #define COOL_HIDDEN_CHAR 4 #define COOL_HIDDEN_UINT 5 #define COOL_HIDDEN_LONG 6 #define COOL_HIDDEN_VOID 7 int cool_hidden_types[12]; int cool_hidden_last = 0; void cool_hidden_add_int() {     cool_hidden_types[cool_hidden_last] = COOL_HIDDEN_INT;     cool_hidden_last += 1; } void cool_hidden_add_string() {     cool_hidden_types[cool_hidden_last] = COOL_HIDDEN_STRING;     cool_hidden_last += 1; } /*аналогично для каждого типа */ void cool_hidden_add_void() {     cool_hidden_types[cool_hidden_last] = COOL_HIDDEN_VOID;     cool_hidden_last += 1; }

COOL_HIDDEN_VOID будет означать, что данный тип не поддерживается функцией. Можно было бы заморочиться и передавать информацию о размере переменной и выводить в 16-ричном виде для любой другой переменной, но я не стал это делать

Создадим теперь generic макро функцию cool_hidden_add(x), которая будет добавлять элемент в массив в зависимости от типа x

#define cool_hidden_add(x)              Generic((x),           int: cool_hidden_add_int,           char*: cool_hidden_add_string,     float: cool_hidden_add_float,     double: cool_hidden_add_double,     char: cool_hidden_add_char,     unsigned int: cool_hidden_add_uint,     long: cool_hidden_add_long,     default: cool_hidden_add_void )()

Это было самое простое…

II. Определение числа аргументов на уровне макроса

Идея заключается в том, чтобы определить макрос вида cool_print##n(x1, x2, ..., xn) («##» означает конкатенацию со значением n), который по очереди добавляет информацию о типе каждого xi, а затем передает в функцию реализации cool_hidden_print(sep, n, x1, x2, ...) разделитель, n, и все xi. Разделитель я определю как глобальную (если так вообще можно называть переменные с уникальной приставкой) переменную cool_print_sep = " ", которую можно изменить в любой момент

Определим это простым образом через копирование. Хотя наверное их можно было бы сгенерировать макросами, но мне было уже лень. (К тому же у меня и так статический анализатор visual studio заблудился в куче макросов и указывает ошибку там, где все нормально компилируется, но об этом позже)

В общем виде это выглядит так: #define cool_print_n(x1, x2, x3, x4, ..., xn, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     ...................     cool_hidden_add(xn);     cool_hidden_print(cool_print_sep, 6, x1, x2, x3, x4, ..., xn) 

 #if 1 or "hide this a big part of code" #define cool_print_12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_add(x7);     cool_hidden_add(x8);     cool_hidden_add(x9);     cool_hidden_add(x10);     cool_hidden_add(x11);     cool_hidden_add(x12);     cool_hidden_print(cool_print_sep, 12, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) #define cool_print_11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_add(x7);     cool_hidden_add(x8);     cool_hidden_add(x9);     cool_hidden_add(x10);     cool_hidden_add(x11);     cool_hidden_print(cool_print_sep, 11, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) #define cool_print_10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_add(x7);     cool_hidden_add(x8);     cool_hidden_add(x9);     cool_hidden_add(x10);     cool_hidden_print(cool_print_sep, 10, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) #define cool_print_9(x1, x2, x3, x4, x5, x6, x7, x8, x9, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_add(x7);     cool_hidden_add(x8);     cool_hidden_add(x9);     cool_hidden_print(cool_print_sep, 9, x1, x2, x3, x4, x5, x6, x7, x8, x9) #define cool_print_8(x1, x2, x3, x4, x5, x6, x7, x8, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_add(x7);     cool_hidden_add(x8);     cool_hidden_print(cool_print_sep, 8, x1, x2, x3, x4, x5, x6, x7, x8) #define cool_print_7(x1, x2, x3, x4, x5, x6, x7, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_add(x7);     cool_hidden_print(cool_print_sep, 7, x1, x2, x3, x4, x5, x6, x7) #define cool_print_6(x1, x2, x3, x4, x5, x6, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_add(x6);     cool_hidden_print(cool_print_sep, 6, x1, x2, x3, x4, x5, x6) #define cool_print_5(x1, x2, x3, x4, x5, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_add(x5);     cool_hidden_print(cool_print_sep, 5, x1, x2, x3, x4, x5) #define cool_print_4(x1, x2, x3, x4, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_add(x4);     cool_hidden_print(cool_print_sep, 4, x1, x2, x3, x4) #define cool_print_3(x1, x2, x3, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_add(x3);     cool_hidden_print(cool_print_sep, 3, x1, x2, x3) #define cool_print_2(x1, x2, ...)       cool_hidden_add(x1);     cool_hidden_add(x2);     cool_hidden_print(cool_print_sep, 2, x1, x2) #define cool_print_1(x, ...)       cool_hidden_add(x);     cool_hidden_print(cool_print_sep, 1, x) #endif //"hide this a big part of code" 

Немного проспойлерил, что аргументов макро функции cool_print_n всегда 12, и что после нее идет ..., но об этом далее

Значение выполнения макроса PP_NARG(VA_ARGS) не возможно подставить напрямую в выражение cool_print_##PP_NARG(VA_ARGS), так как оно развернется в что-то вроде cool_print_PP_NARG("x", 5, "i", 8,), что не имеет никакого смысла. Поэтому надо использовать код из макроса, но не возвращать число аргументов, а сразу конкатенировать

#ifndef PP_NARG /*       The PP_NARG macro returns the number of arguments that have been    passed to it.     https://groups.google.com/g/comp.std.c/c/d-6Mj5Lko_s  /  #define PP_NARG(...)     PP_NARG_(VA_ARGS,PP_RSEQ_N()) #define PP_NARG_(...)     PP_ARG_N(VA_ARGS) #define PP_ARG_N( _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, _61,_62,_63, N, ...) N #define PP_RSEQ_N() 63,62,61,60, 59,58,57,56,55,54,53,52,51,50, 49,48,47,46,45,44,43,42,41,40, 39,38,37,36,35,34,33,32,31,30, 29,28,27,26,25,24,23,22,21,20, 19,18,17,16,15,14,13,12,11,10, 9,8,7,6,5,4,3,2,1,0 #endif

 #define cool_print(...)     cool_print_(VA_ARGS , COOL_RSEQ_N()) #define cool_print_(...)     COOL_ARG_N(VA_ARGS) #define COOL_ARG_N(     _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, _11,_12,_13,_14,_15,_16,_17,_18,_19,_20,     _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, _31,_32,_33,_34,_35,_36,_37,_38,_39,_40,     _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, _51,_52,_53,_54,_55,_56,_57,_58,_59,_60,     _61,_62,63, n, ...)                             cool_print##n(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11,_12) #define COOL_RSEQ_N()     63,62,61,60,59,58,57,56,55,54,53,52,51,50,     49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,     29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,     9,8,7,6,5,4,3,2,1,0 

Как это работает:

1. Условно происходит вызов cool_print("a", 4, "b")  Это превращается в cool_print_("a", 4, "b", 63,62,61,60,59,58,57,56,55,54,53,52,51,50,  49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,  29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,  9,8,7,6,5,4,3,2,1,0  Затем из cool_print_ это все передается в макрос COOL_ARG_N,   который способен принять 64 аргумента. В 64-й аргумент, названный n попадает как раз количество исходных аргументов из-за того, что при добавление аргументов VA_ARGS перед последовательностью COOL_RSEQ_N  (63..0) часть чисел из этой последовательности вытесняется  В конце концов в макросе COOL_ARG_N просиходит конкатенация cool_print_##n   и вызов этого макроса. В данном примере это cool_print_3 cool_print_3("a", 4, "b", 63,62,61,60,59,58,57,56,55,54,53,52,51,50,  49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,  29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,  9,8,7,6,5,4,3)  Всего передается 12 аргументов, так как невозможно обрезать лишние.    И это и не надо, так как благодаря "..." в списке аргументов каждого макроса cool_print_##n они способны проглотить ненужный хвост  Так же можно было бы сократить число аргументов с 64 до 12,    но я посчитал это не очень важным 

III. Собственно реализация функции

Отлично, у нас при вызове cool_print("наши", "аргументы", 10) происходит заполнение массива cool_hidden_types информацией о типе каждого аргумента, а затем вызывается функция реализации cool_hidden_print(int sep, int n, ...)! Давайте напишем эту функцию

Суть такова: в цикле перебираются все элементы все элементы. В swich’e каждый элемент кастится в void’ый указатель x, а затем вызывается в виде printf("...%s", *((type) x), sep), где type — это тип аргумента, а «…» — это специфичный для данного типа формат вывода. Например для int это printf("%d%s", *((type) x), sep). Для упрощенной записи приведения типов я использую вспомогательный макрос #define COOL_CAST(T, x) ((T) (x))

#define COOL_CAST(T, x) ((T) (x))   void cool_hidden_print(char* sep, int n, ...) {     va_list argptr;     va_start(argptr, n); void* x;  for (int i = 0; i < n; i++) {     switch (cool_hidden_types[i])     {     case COOL_HIDDEN_INT:         x = &va_arg(argptr, int);         printf("%d%s", COOL_CAST(int, x), sep);         break;      case COOL_HIDDEN_STRING:         x = &va_arg(argptr, char*);         printf("%s%s", COOL_CAST(char*, x) , sep);         break;      case COOL_HIDDEN_FLOAT:         x = &va_arg(argptr, float);         printf("%.4f%s", COOL_CAST(float, x), sep);         break;      case COOL_HIDDEN_DOUBLE:         x = &va_arg(argptr, double);         printf("%.4f%s", COOL_CAST(double, x), sep);         break;      case COOL_HIDDEN_CHAR:         x = &va_arg(argptr, char);         printf("%c%s", COOL_CAST(char, x), sep);         break;      case COOL_HIDDEN_UINT:         x = &va_arg(argptr, unsigned int);         printf("%.4u%s", COOL_CAST(unsigned int, x), sep);         break;      case COOL_HIDDEN_VOID:         printf("unsupported type%s", sep);         break;      default:         printf("Internal COOL/CPRINT error line: %d in %s", __LINE__, __FILE__);         break;     }  }  va_end(argptr); cool_hidden_last = 0;  }

Дополнительные мелочи

После подключения библиотеки можно избавиться от приставки cool_ с помощью

#define print cool_print

Идеально, теперь наша функция print полностью работает! В качестве вишенки на торте определим функцию println, которая после вывода переводит нас на новую строку

#define cool_println(...)     cool_print(VA_ARGS);    printf("\n") #define cool_printlnn() printf("\n")

К моему большому сожалению я не смог решить проблему, что при вызове макроса без аргументов происходит синтаксическая ошибка из-за лишней запятой в начале, поэтому без аргументов нужно вызывать printlnn()… Я пытался решить это, при определении cool_print

ни так #define cool_print(...)     cool_print_(VA_ARGS , ## COOL_RSEQ_N() ни так #define cool_print(...)     cool_print_(VA_ARGS ## , COOL_RSEQ_N() все равно не работает

Как советуют в интернете делать при таком случае ничего не происходит. Видимо эта запись работает только для ,## VA_ARGS, когда VA_ARGS идет в конце, а не в начале

Возможно можно как-нибудь еще одним вложенным макросом определить, является ли VA_ARGS пустым. Я нашел в гугле решение только тогда когда максимум 2 аргумента

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

У меня почему-то сработало один раз (,), но после перезапуска visual stidio стало VAR_OPT не определено. К тому же в том месте VAR_OPT ставить нельза, так как макрос будет считать что у нас 63 а не 64 аргумента (что приводила к ошибке вызова не того cool_print##n (на единицу меньше). Нужно что-то вроде

#define cool_print(...)     VAR_OPT(  cool_print_(VA_ARGS , COOL_RSEQ_N())  ) вместо текущего #define cool_print(...)        cool_print_(VA_ARGS , COOL_RSEQ_N())

Проблемы этого метода

• Первое — это конечно же невозможность вызвать функцию без аргументов. К тому же огромным минусом является то, что в случае ошибки генерируется очень невнятное сообщение об ошибке, и я не вижу куда можно вставить его

• Второе — сложность реализации. На C++ аналогичная функция выглядит намного проще. Хотя, имея в качестве шаблона мою функцию print будет не так сложно реализовать любую другую

• Третье — статический анализатор. В visual studio у меня подчеркнут красным каждый print и println со словами «требуется выражение», и висит по одной ошибки (прям красным цветом) на каждый вызов этой функции. Не смотря на это все нормально компилируется. И даже не думаю что на это должно тратиться сильно больше времени, чем на раскрытие variadic templates в c++, хотя я тесты не проводил (а как вообще замерить время компиляции — это отдельный вопрос)

  Этот минус самый пожалуй критичный. Если знаете как можно подавить эти ложные ошибки, то подскажите в комментариях

При этом компилируется прекрасно

Полный код данной библиотечки можете найти по ссылке на моем гитхабе: print.h

А вот пример использования c_example.c

Заключение

Удивительно сколько всего можно сделать на чистом Си с очень слабыми шаблонами. Но все же Си предназначен не совсем для этого. Данная статья нужна в большей мере для интереса, хотя может кому-нибудь и поможет в работе. Для удобств написания кода на Си как раз и был создан C++, который позволяет работать с обьектами через класс, а не писать id обьекта первым параметром в методах; он позваляет делать перегрузку функций для тех случаев, когда это необходимо (чтобы не городить функции типа pow, powi, powf); упрощает работу с указателями, добавляя ссылки, добавляет пространства имен, чтобы не городить приставок, добавляет контейнеры. Но как итог всего этого — медленная компиляция

Вот пример реализации этой же функции print на C++:

#ifndef COOL_PRINT_HPP #define COOL_PRINT_HPP #include <string> #include <iostream> #include <iomanip> namespace {     std::ostream* out = &std::cout; } namespace cool {     inline void setCyrillic()     {         setlocale(LC_ALL, "Russian");     } void setPrintOut(std::ostream&amp; os) {     ::out = &amp;os; }  std::ostream* getPrintOutPtr() {     return ::out; }  inline void printFlush() {     *::out &lt;&lt; std::flush; }  inline void print()  {      *::out &lt;&lt; ' '; }  template &lt;typename Arg&gt; inline void print(const Arg&amp; arg) {     *::out &lt;&lt;  std::fixed &lt;&lt; std::setprecision(4) &lt;&lt; arg &lt;&lt; ' '; }  template &lt;typename Arg, typename... Args&gt; void print(const Arg&amp; arg, const Args&amp;... args) {     print(arg);     print(args...); } ////  inline void println() {     *::out &lt;&lt; '\n'; } template &lt;typename Arg&gt; inline void println(const Arg&amp; arg) {     *::out &lt;&lt; std::fixed &lt;&lt; std::setprecision(4) &lt;&lt; arg &lt;&lt; '\n'; }  template &lt;typename... Args&gt; void println(const Args&amp;... args) {     print(args...);     println(); } /// void print0() { }  template &lt;typename Arg&gt; inline void print0(const Arg&amp; arg) {     *::out &lt;&lt; std::fixed &lt;&lt; std::setprecision(4) &lt;&lt; arg; }  template &lt;typename Arg, typename... Args&gt; void print0(const Arg&amp; arg, const Args&amp;... args) {     print0(arg);     print0(args...); }  } #endif 

Более понятно, примерно в 3 раза меньше кода, и реализация более полноценная. Но в то же время стандартный printf хоть и выглядит не так изящно, но зато быстрый и практичный. Каждому языку свое место