可以使用多个_Generic来创建字符串文字吗？

Question

有没有办法在同一个表达式中多次使用_Generic关键字来创建单个字符串文字？

我正在寻找的是一种方法，例如生成一个传递给printf的单个格式字符串，所有转换说明符都适合于正确的类型。

在写这个答案时，我最终得到了一个相当丑陋的解决方法：

#include <stdio.h>

typedef struct {
   int a;
   char b;
   long c;
} ABC;

// printf conversion specifiers:
#define CS(x)   \
  _Generic((x), \
    int:  "%d", \
    char: "%c", \
    long: "%ld")


int main (void)
{
  ABC abc = {1, 'a', 2};

  printf(CS(abc.a), abc.a); printf(" ");
  printf(CS(abc.b), abc.b); printf(" ");
  printf(CS(abc.c), abc.c); printf(" ");

  return 0;
}

6个printf来代替1，几乎不理想。

问题是我找不到通过预处理器组合_Generic和字符串文字串联的方法，如下所示：

printf(CS(abc.a) " ", abc.a); // doesnt work
printf(CS(abc.a) CS(abc.b), abc.a, abc.b); // doesnt work either

因为显然通用的宏在预处理器中不算作字符串文字，所以字符串文字串联是不可能的。 我玩弄了“stringification”宏，但那里没有运气。

Answer 1

我要说的答案是否定的。

首先， _Generic关键字不是（并且不可能是）预处理器指令。 泛型选择是主要表达式，如6.5.1节中所定义。 鉴于输入

printf(CS(abc.a) "hello", abc.a);

预处理器的输出（由-E编译器选项生成）是：

printf(_Generic((abc.a), int: "%d", char: "%c", long: "%ld") "hello", abc.a);

请注意，由于尚未评估泛型选择，因此无法进行字符串连接。 还要注意，预处理器不可能进行评估，因为它需要知道abc是ABC类型的结构，它具有成员a 。 预处理器执行简单的文本替换，它不了解这些事情。

其次，第5.1.1.2节中定义的编译器阶段不允许在字符串连接之前评估_Generic关键字。 从规范中引用的相关阶段是

6. 相邻的字符串文字标记是连接的。

7. 分隔标记的空白字符不再重要。 每个预处理令牌都转换为令牌。 由此产生的标记在语法和语义上进行分析并翻译为翻译单元。

_Generic关键字必须在阶段7中进行评估，因为它需要的知识仅在对语法进行语法和语义分析后才可用，例如， abc是具有成员a的结构。 因此，多个_Generic关键字无法利用字符串连接来生成单个字符串文字。

Answer 2

不错的问题，你可以粘贴一个字符串传递另一个参数：

#include <stdio.h>

typedef struct {
    int a;
    char b;
    long c;
} ABC;

// printf conversion specifiers:
#define CS2(x, y)   \
    _Generic((x), \
     int:  "%d" y, \
     char: "%c" y, \
     long: "%ld" y) 

int main (void)
{
    ABC abc = {1, 'a', 2};

    printf(CS2(abc.a, "Hello"), abc.a);
    return 0;
}

Answer 3

仅仅为了记录，事实证明可以在编译时基于_Generic生成一个字符串常量，使用除预处理器可用的其他脏技巧。

我提出的解决方案是如此丑陋，我几乎不敢发布它，但我会这样做只是为了证明它是可能的。

不要写这样的代码！

#include <stdio.h>

typedef struct {
   int a;
   char b;
   long c;
} ABC;

// printf conversion specifiers:
#define CS(x)   \
  _Generic((x), \
    int:  "%d", \
    char: "%c", \
    long: "%ld")

#pragma pack(push, 1)
#define print2(arg1,arg2)              \
{                                      \
  typedef struct                       \
  {                                    \
    char arr1 [sizeof(CS(arg1))-1];    \
    char space;                        \
    char arr2 [sizeof(CS(arg2))-1];    \
    char nl_nul[2];                    \
  } struct_t;                          \
                                       \
  typedef union                        \
  {                                    \
    struct_t struc;                    \
    char     arr [sizeof(struct_t)];   \
  } cs2_t;                             \
                                       \
  const cs2_t cs2 =                    \
  {                                    \
    .struc.arr1 = CS(arg1),            \
    .struc.space = ' ',                \
    .struc.arr2 = CS(arg2),            \
    .struc.nl_nul = "\n"               \
  };                                   \
                                       \
  printf(cs2.arr, arg1, arg2);         \
}
#pragma pack(pop)

int main (void)
{
  ABC abc = {1, 'a', 2};

  print2(abc.a, abc.b);
  print2(abc.a, abc.c);
  print2(abc.b, abc.c);

  return 0;
}

输出：

1 a
1 2
a 2

说明：

宏print2是printf的包装器，无论类型如何，都使用正确的转换说明符打印2个参数。

它构建一个基于结构的字符串，转换说明符字符串文字传递给该字符串。 这种转换说明符的每个数组占位符都故意声明太小而不适合空终止。

最后，将此结构转储到一个union ，该union可以将整个结构解释为单个字符串。 当然这是非常值得怀疑的做法（即使它没有违反严格的别名）：如果有任何填充，那么程序将失败。