Abdulmalek Almkainzi's questions

Quero uma macro para detectar se o argumento passado está entre parênteses ou não e, se for o caso, chamar uma macro diferente.

por exemplo

#define FOO(obj) BAR obj
#define BAR(...) func(__VA_ARGS__)
#define BAR

Se eu chamar isso com FOO((1, 2, 3))ele se expandiria para func(1, 2, 3). Mas se eu chamar isso com FOO(1)ele deveria se expandir para1

Eu sei que sobrecarga de macro não é uma coisa em C, mas estou pensando se há outra maneira de atingir esse comportamento a partir de FOO. Eu pesquisei vários truques de macro, mas não consegui descobrir uma maneira de fazer isso.

Estou trabalhando em uma biblioteca de macros e preciso desse comportamento exato.

Qual o tamanho que uma string alocada na pilha precisa ter para armazenar qualquer float/double no formato% g?

int main()
{
    float f;
    double d;
    
    char f_str[ ?? ];
    char d_str[ ?? ];
    
    sprintf(f_str, "%g",  f);
    sprintf(d_str, "%lg", d);
}

Editar:

Quero que o tamanho da string seja conhecido em tempo de compilação, de modo que não dependa de alocação de heap ou VLAs

por exemplo:

typedef struct S { int i; char c; } S;

#define MAKE_CLITERAL(T) ((typeof(T)) {T})

int main()
{
    S s = {.i = 500, .c = 'a'};

    S s2 = MAKE_CLITERAL(s); // doesn't compile
}

Quero que a macro MAKE_CLITERALtransforme qualquer valor em um literal composto.

de modo que fazer algo como MAKE_CLITERAL( 10 )e MAKE_CLITERAL( s )ambos criem literais compostos de seu tipo.

Eu tentei fazer isso:

#define MAKE_CLITERAL(T) ( (typeof(T)){} = T );

mas não se comporta exatamente como um literal composto, então isso não funciona:

&MAKE_CLITERAL(s); // compiler says this is an rvalue

Existe uma maneira de inicializar um literal composto usando um valor do mesmo tipo?