Concatena stringa letterale con char letterale

Question

Desidero concatenare una stringa letterale e char letterale. Essendo sintatticamente corretto, "abc" 'd' "efg" rende un errore di compilazione:

x.c:4:24: error: expected ',' or ';' before 'd'

Ormai devo usare snprift (inutilmente), nonostante il valore della stringa letterale e l'essere letterale char conoscere al momento della compilazione.

Ho provato

#define CONCAT(S,C) ({ \ 
    static const char *_r = { (S), (C) }; \ 
    _r; \ 
}) 

ma non funziona perché il terminatore null S non viene rimosso. (Oltre di dare gli avvisi del compilatore.)

C'è un modo per scrivere una macro per usare

• "abc" MACRO('d') "efg" o
• MACRO1(MACRO2("abc", 'd'), "efg") o
• MACRO("abc", 'd', "efg")?

Nel caso in cui qualcuno chieda perché lo voglio: Il char letteral proviene da una libreria e devo stampare la stringa come messaggio di stato.

Answer 1

C consente solo di concatenare stringhe letterali. In realtà, non c'è niente di sbagliato con snprintf(). Si potrebbe anche usare strcpy():

strcpy(dest, str1); 
dest[strlen(dest)] = c; 
strcpy(dest + strlen(dest) + 1, str2); 

Si potrebbe anche usare un gigante switch dichiarazione per superare questa limitazione:

switch(c) { 
    case 'a': 
     puts("part1" "a" "part2"); 
     break; 
    case 'b': 
     puts("part1" "b" "part2"); 
     break; 

    /* ... */ 

    case 'z': 
     puts("part1" "z" "part2"); 
     break; 
} 

... ma mi rifiuto di rivendicare alcun autore.

Per dirla in breve, basta attaccare con snprintf().

Answer 2

Se si può vivere con le virgolette singole essere inclusi con esso, è possibile utilizzare in stringa:

#define SOME_DEF 'x' 

#define STR1(z) #z 
#define STR(z) STR1(z) 
#define JOIN(a,b,c) a STR(b) c 

int main(void) 
{ 
    const char *msg = JOIN("Something to do with ", SOME_DEF, "..."); 

    puts(msg); 

    return 0; 
} 

A seconda del contesto che può o non può essere appropriato, ma per quanto convincente che sia in realtà una stringa letterale in questo modo, è l'unico modo che mi viene in mente senza formattazione in fase di runtime.

Answer 3

Prova questo. Utilizza il trucco macro C di macro doppi in modo che l'argomento macro abbia la possibilità di espandersi prima di essere sottoposto a stringa.

#include <stdio.h> 

#define C d 
#define S "This is a string that contains the character " 
#define STR(s) #s 
#define XSTR(s) STR(s) 

const char* str = S XSTR(C); 

int main() 
{ 
    puts(str); 
    return 0; 
} 

Answer 4

mi si avvicinò con una soluzione specifica per GCC che non mi piace troppo, come non si può usare CONCAT nestedly.

#include <stdio.h> 

#define CONCAT(S1,C,S2) ({      \ 
    static const struct __attribute__((packed)) { \ 
     char s1[sizeof(S1) - 1];     \ 
     char c;         \ 
     char s2[sizeof(S2)];      \ 
    } _r = { (S1), (C), (S2) };     \ 
    (const char *) &_r;       \ 
}) 

int main(void) { 
    puts(CONCAT ("abc", 'd', "efg")); 
    return 0; 
} 

http://ideone.com/lzEAn