La respuesta aceptada por @chqrlie 100% explica lo que está sucediendo. Este es solo un comentario complementario.

Si usamos C++, podríamos definir dos funciones de plantilla para proporcionar todas las implementaciones de vsenc8 , vsenc16 , vsenc32 , vsenc64 y vsdec8 , vsdec16 , vsdec32 , vsdec64 . Sin embargo, en contraste, C es un lenguaje muy simple y no admite plantillas. Un truco común para tener el mismo poder (en un empaque más feo) es usar la función de macro tonta del lenguaje y dejar que el preprocesador C haga el trabajo equivalente por nosotros. La mayoría de los programadores de C con cierta experiencia encontrarán y usarán este tipo de construcción repetidamente durante sus carreras.

Lo que hace que este ejemplo en particular sea un poco tedioso de entender es que el archivo de implementación se analiza de manera poco convencional 5 veces para tener primero algunas definiciones preparatorias y luego las cuatro variantes de las dos funciones. El primer paso (dentro del bloque de preprocesador #ifndef USIZE ) tendrá definidas las macros necesarias y el material no variable y se #include incluirá recursivamente cuatro veces con diferentes valores de USIZE ( 8 , 16 , 32 , 64 ) como valores de plantilla. Cuando se incluye recursivamente, el bloque de preprocesador #else correspondiente se analiza con el resultado de dos funciones generadas de acuerdo con el valor de la constante macro USIZE utilizada para el paso.

Una forma más convencional, conceptualmente más clara y comprensible al instante sería incluir las funciones de plantilla de archivos diferentes, por ejemplo, vsimple.impl :

 #define USIZE 8 /* Generate vsenc8(), vsdec8()... */ #include "vsimple.impl" #undef USIZE #define USIZE 16 /* Generate vsenc16(), vsdec16()... */ #include "vsimple.impl" #undef USIZE #define USIZE 32 /* Generate vsenc32(), vsdec32()... */ #include "vsimple.impl" #undef USIZE #define USIZE 64 /* Generate vsenc64(), vsdec64()... */ #include "vsimple.impl"

El archivo incluido vsimple.c y el archivo incluido vsimple.impl también podrían organizarse para ser mucho más claros en lo que definen y cuándo. La mayoría de los programadores de C reconocerían el patrón de implementación e inmediatamente sabrían lo que está sucediendo.

Incluirse recursiva y repetidamente a sí mismo de esta manera invoca una sensación de magia que atraería aplausos para una entrada ofuscada de competencia C pero no para el código de producción de misión crítica.

es recursividad. La recursividad es útil aquí porque el preprocesamiento de C no tiene bucles. Además, es deseable perpetrar un truco utilizando un archivo en lugar de proliferar varios archivos.

Suponga que se le pide que escriba una función que interpole los números enteros del 1 al 5 en una cadena de plantilla y la imprima en la salida estándar. Suponga que se le pidió que escribiera exactamente una función y se le prohibieron los bucles o las instrucciones printf copiadas y pegadas. Podrías hacer esto:

 void template_print(const char *fmt, int n) { if (n == 0) { template_print(fmt, 1); template_print(fmt, 2); template_print(fmt, 3); template_print(fmt, 4); template_print(fmt, 5); } else { /* imagine there are 30 lines of statements here we don't want to repeat five times. */ printf(fmt, n); } }

La llamada de nivel superior a esto es template_print("whatever %d\n", 0) que se distingue por el argumento cero del parámetro n .

La llamada de nivel superior con 0 es como el procesamiento inicial de vsimple.c sin que se defina USIZE .

El requisito de una función es similar a tener que producir un único archivo .c independiente en lugar de un archivo de "interfaz" que #include una implementación.