_Generic форматирование строки в С

printf("Значение " PFMT(k) " вне заданного диапазона\n", k);

#include <stdio.h>
#include <stdlib.h>

struct DPOINT2
{
   double X,Y;
} DPOINT2;

struct FPOINT2
{
   float X,Y;
} FPOINT2;

#define MSG1 "Значение"
#define MSG2 "вне заданного диапазона\n"

void p_int(int x)
{
    printf( MSG1 " i %d " MSG2, x);
}

void p_long(long x)
{
    printf( MSG1 " l %ld " MSG2, x);
}

void p_double(double x)
{
    printf( MSG1 " d %f  " MSG2, x);
}

void p_float(float x)
{
    printf( MSG1 " f %f  " MSG2, x);
}

void p_fpoint(struct FPOINT2 x)
{
    printf( MSG1 " d(%6.3f, %6.3f) " MSG2 ,x.X,x.Y);
}

void p_dpoint(struct DPOINT2 x)
{
    printf( MSG1 " f(%6.3f, %6.3f) " MSG2 ,x.X,x.Y);
}

#define PRINT(x)                   \
  _Generic( (x),                    \
    int               : p_int,      \
    long              : p_long,     \
    double            : p_double,   \
    float             : p_float,    \
    struct DPOINT2    : p_dpoint,   \
    struct FPOINT2    : p_fpoint )(x)



int main(int argc, char *argv[])
{

    struct DPOINT2 dp = {.X=42.0, .Y=0.42};
    struct FPOINT2 fp = {.X=42.0, .Y=0.42};

    PRINT(dp);
    PRINT(((struct DPOINT2){42.0,0.42}));

    PRINT(fp);
    PRINT(((struct FPOINT2){42.0,0.42}));

    PRINT(1);
    PRINT(1L);
    PRINT(1.0f);
    PRINT(1.0);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

struct DPOINT2
{
   double X,Y;
} DPOINT2;

struct FPOINT2
{
   float X,Y;
} FPOINT2;


#define MSG1 "Значение"
#define MSG2 "вне заданного диапазона\n"

#define PRINT2(x)                                                       \
  _Generic( (x),                                                        \
    struct DPOINT2    : printf( MSG1 " d(%6.3f, %6.3f) " MSG2 ,x.X,x.Y),\
    struct FPOINT2    : printf( MSG1 " f(%6.3f, %6.3f) " MSG2 ,x.X,x.Y) )

#define PRINT1(x)                                       \
  _Generic( (x),                                        \
    int               : printf( MSG1 " i %d  " MSG2, x),\
    long              : printf( MSG1 " l %ld " MSG2, x),\
    double            : printf( MSG1 " d %f  " MSG2, x),\
    float             : printf( MSG1 " f %f  " MSG2, x) )


int main(int argc, char *argv[])
{

    struct DPOINT2 dp = {.X=42.0, .Y=0.42};
    struct FPOINT2 fp = {.X=42.0, .Y=0.42};

    PRINT2(dp);
    PRINT2(((struct DPOINT2){42.0,0.42}));


    PRINT2(fp);
    PRINT2(((struct FPOINT2){42.0,0.42}));

    PRINT1(1);
    PRINT1(1L);
    PRINT1(1.0f);
    PRINT1(1.0);

    return 0;
}

#define PRINT1(x)                                       \
  _Generic( (x),                                        \
    int               : printf( MSG1 " i %d  " MSG2, x),\
    long              : printf( MSG1 " l %ld " MSG2, x),\
    double            : printf( MSG1 " d %f  " MSG2, x),\
    float             : printf( MSG1 " f %f  " MSG2, x),\
    struct DPOINT2    : printf( MSG1 " d(%6.3f, %6.3f) " MSG2 ,x.X,x.Y),\
    struct FPOINT2    : printf( MSG1 " f(%6.3f, %6.3f) " MSG2 ,x.X,x.Y) )

#include <stdio.h> 
#include <string.h>
#include <errno.h>
#include <locale.h>

int main(int argc, char **argv)
{
  setlocale(LC_ALL, "");
  printf("%s: %d\n", strerror(ERANGE), argc);
  return 0;
}

$ LC_ALL=ru_RU.UTF-8 ./a.out
Числовой результат вне представимого диапазона: 1

$ LC_ALL=en_US.UTF-8 ./a.out
Numerical result out of range: 1

int k=7;
printf("AAAAAAAAAAAA "PFMT(k)" BBBBBBBBBBB", k);

In function ‘main’:
dynarr_use.c:35:27: error: expected ‘)’ before ‘_Generic’
   35 |     printf("AAAAAAAAAAAA "PFMT(k)" BBBBBBBBBBB", k);
      |                           ^
      |                           )

#define FPRINT(output, x)\
  _Generic( (x),\
     unsigned char       : fprintf_byte,  \
     int                 : fprintf_int,   \
     long                : fprintf_long,  \
     float               : fprintf_float, \
     double              : fprintf_double,\
    struct POINT2        : fprintf_pt2,   \
    struct POINT3        : fprintf_pt3,   \
    struct TRIANGLE_INDEX: fprintf_index  \
)(output, x)

fprintf(stdout, "Значение ");
FPRINT (stdout, k);
fprintf(stdout," вне заданного диапазона\n");

// это не работает!
printf("Значение "PFMT(k)" вне заданного диапазона\n", k);

#include <stdarg.h>
#include <stdio.h>


typedef struct POINT2
{
    float X,Y;
} POINT2;

typedef struct dPOINT2
{
    double X,Y;
} dPOINT2;

#define TO_DBL(pt) (dPOINT2){.X = (double) pt.X, .Y = (double) pt.Y}


int my_printf(const char *format, ...)
{
    va_list args;
    va_start(args, format);

    size_t i = 0;
    while (format[i])
    {
        if (format[i] == '%')
        {
            i++;
            switch (format[i])
            {
                case 'd':
                {
                    int x = va_arg(args, int);
                    printf("%d", x);
                    break;
                }
                case 'f':
                {
                    double x = va_arg(args, double);
                    printf("%f", x);
                    break;
                }
                case 'c':
                {
                    int x = va_arg(args, int);
                    printf("%c", x);
                    break;
                }
                case 's':
                {
                    char *x = va_arg(args, char*);
                    printf("%s", x);
                    break;
                }
                case 'x':
                case 'X':
                {
                    int x = va_arg(args, int);
                    printf("%x", x);
                    break;
                }
                case 'p':
                {
                    void *x = va_arg(args, void*);
                    printf("%p", x);
                    break;
                }
                case 'q':
                {
                    double x = va_arg(args, double);
                    double y = va_arg(args, double);
                    printf("(%3.3f, %3.3f)", x, y);
                    break;
                }
                case '%':
                    putchar('%');
                    break;

                case '\0':
                    i--;
                    break;

                default:
                    putchar(format[i]);
                    break;
            }
        }
        else
        {
            putchar(format[i]);
        }
        i++;
    }

    va_end(args);
    return 0;
}



#define PFMT(x)                         \
  _Generic( (x),                        \
    char              : "%c",           \
    int               : "%d",           \
    long              : "%ld",          \
    double            : "%f",           \
    float             : "%f",           \
    char*             : "%s",           \
    struct  POINT2    : "%q"            \
)


static void printf_pt2(const char* fmt, const POINT2 pt)
{
    my_printf(fmt, TO_DBL(pt));
}



#define UNIVERS_PRINT(x)\
  _Generic( (x),\
    struct POINT2 : printf_pt2,  \
    default       : my_printf    \
)(PFMT(x), (x))





int main(void)
{
    int x = 5;
    double y = 3.14;
    char c = 'a';
    char *str = "Hello World!";
    POINT2 pt = (POINT2){4.444, 7.777};

    my_printf("The value of x is %d,\n y is %f,\n c is %c,\n str is %s,\n point is %q\n",
              x, y, c, str, TO_DBL(pt) );


    UNIVERS_PRINT(x);   putchar('\n');
    UNIVERS_PRINT(y);   putchar('\n');
    UNIVERS_PRINT(c);   putchar('\n');
    UNIVERS_PRINT(str); putchar('\n');
    UNIVERS_PRINT(pt);  putchar('\n');
    return 0;
}

The value of x is 5,
 y is 3.140000,
 c is a,
 str is Hello World!,
 point is (4.444, 7.777)
5
3.140000
a
Hello World!
(4.444, 7.777)
[Finished in 60ms]

   double x = va_arg(args, double);
   double y = va_arg(args, double);

#define TO_DBL(pt) (dPOINT2){.X = (double) pt.X, .Y = (double) pt.Y}

#define TO_DBL(pt) (double) pt.X, (double) pt.Y

         ...
                case 'q':
                {
                    POINT2 p = va_arg(args, POINT2);
                    printf("(%3.3f, %3.3f)", p.X, p.Y);
                    break;
                }
         ...

/*
#define UNIVERS_PRINT(x)\
  _Generic( (x),\
    struct POINT2 : printf_pt2,  \
    default       : my_printf    \
)(PFMT(x), (x))
*/

#define UNIVERS_PRINT(x) my_printf(PFMT(x), (x))

static void fprintf_NEW_TYPE(FILE *output, const NEW_TYPE nt)
{
    fprintf(output,  " конкретный формат ", что-то конкретное);
}

#define FPRINT(output, x)\
  _Generic( (x),\
     unsigned char       : fprintf_byte,  \
     int                 : fprintf_int,   \
     long                : fprintf_long,  \
     float               : fprintf_float, \
     double              : fprintf_double,\
    struct POINT2        : fprintf_pt2,   \
    struct NEW_TYPE      : fprintf_NEW_TYPE\
)(output, x)

struct array {
  void *data;

  // size это то что обычно понимается под размером массива, 
  // если в массиве 5 элементов, то и size будет равен 5
  //
  // capacity это размер выделенной памяти, в пустом массиве 
  // это 0, в массиве до с 1..16 элементами capacity будет 16,
  // в массиве с 24 элементами 32, и далее так она и растет 
  // 0, 16, 32, 64, 128, 256, 512, ... Такой подход позволяет
  // не вызывать каждый раз realloc при добавлении элемента, а
  // только когда size достигает capacity, тогда capacity 
  // увеличивается в два раза, и можно черпать новые элементы
  //
  // Полезно заранее выставить capacity к примеру в 1000 
  // элементов, что бы обойтись в среднем парой вызовов realloc
  // на всю жизнь массива
  size_t capacity 
  size_t size;

  // Можно постоянно передавать размер элемента через аргументы
  // но мне это не нравится
  size_t element_size;
};

// Этот union не будет работать, но суть в том что
// освобожденные элементы образуют список из которого можно
// брать элементы для выделения. Вместо union просто type cast. 
union slot {
  uint32_t prev_free;
  char element[];
};

// Пул строится на массиве, а значит он так же поддерживает
// capacity который можно заранее установить
//
// Еще одно его преимущество для выделения множества объектов,
// это то, что пул можно убить одним free, вместе со всеми его 
// элементами, а не проходится по каждому элементу с free если
// каждый отдельный выделен через обычный malloc
struct pool {
  union slot *memory;
  size_t capacity;
  size_t size;
  size_t element_size;
  
  // При realloc указатели сбиваются, поэтому хорошо иметь
  // флаг запрещающий делать realloc после инициализации с 
  // определенным размером
  bool lock;
};

// Из пула можно выделять элементы, быстрее чем через malloc и
// уплотненно, так как нету никаких заголовков или 
// дополнительного выравнивания
void *pool_alloc(struct pool *self);

// Можно освобождать элементы, и при выделении новых (alloc)
// ячейки освобожденных элементов будут переиспользованы
void pool_free(struct pool *self, void *p);

// Можно брать индексы элементов в пуле, и хранить не указатели
// на элементы, а их индексы. Использование индексов вместо
// указателей, позволяет сократить использование памяти если
// указателей было много, uint32_t - 4 byte, pointer - 8 byte, 
// и в отличие от указателей, при realloc данных пула,  индексы
// будут указывать все на тот же объект
uint32_t pool_id(struct pool *self, void *p);

// Получение элемента по его индексу
void *pool_at(struct pool *self, uint32_t id);

struct list {
  struct list *prev;
  struct list *next;
  // Все, никаких данных он сам по себе не хранит!
};

// Функции для работы с ними довольно очевидные
...
void list_append(struct list *parent, struct list *child);
...

// А теперь к использованию, выдуманная структура игрока для
// примера
struct player {
  char name[128];
  uint32_t score;

  // Встраивается список таким способом 
  struct list lst;
};

// Теперь можно создать игроков A, B, C, и сделать из них
// список
struct list *players;

players = &A.lst;
list_append(players, &B.lst);
list_append(players, &C.lst);

// Имея указатель на список, и зная структуру на которой он 
// закреплен, легко получить указатель на структуру, достаточно
// вычесть адрес поля списка относительно самой структуры, для 
// этого обычно делается макрос
//
// struct player {
//   char name[128];  <-- 128 byte
//   uint32_t score;  <-- 4 byte
//   struct list lst; <-- 132
//                        player = (list_ptr - 132)
// };

struct list *list_sort(
  struct list *input,

  // Или передавать просто offset
  // Функция для извлечения поля из списка, например 
  // извлечение score из player по списку 
  void *(*extractor)(struct list *), 

  // Стандартная функция сравнения
  int (*comparator)(void *, void *)
);