Comment fonctionne ce code C?

Qu’est-ce a##b & #a ?

  #define f(a,b) a##b #define g(a) #a #define h(a) g(a) main() { printf("%s\n",h(f(1,2))); //how should I interpret this?? [line 1] printf("%s\n",g(f(1,2))); //and this? [line 2] } 

Comment fonctionne ce programme?


La sortie est

 12 f(1, 2) 

Je comprends maintenant comment a##b & #a fonctionne. Mais pourquoi le résultat est-il différent dans les deux cas (ligne 1 et ligne 2)?

Le ## concatène deux jetons ensemble. Il ne peut être utilisé que dans le préprocesseur.

f(1,2) devient 1 ## 2 devient 12 .

L’opérateur # en lui-même renforce les jetons: #a devient "a" . Par conséquent, g(f(1,2)) devient "f(1,2)" lorsque le préprocesseur en a terminé.

h(f(1,2)) est effectivement #(1 ## 2) qui devient #12 qui devient "12" fur et à mesure que le préprocesseur l’exécute.

Pour des questions comme celles-ci (et aussi pour des problèmes plus réels liés au pré-processeur), je trouve très utile de lire le code, après le prétraitement.

Comment faire cela varie avec le compilateur, mais avec gcc, vous utiliseriez ceci:

 $ gcc -E test.c (snip) main() { printf("%s\n","12"); printf("%s\n","f(1,2)"); } 

Ainsi, vous pouvez voir que les symboles ont été concaténés et transformés en chaîne.

un ## b va coller le code togather.

donc f (1,2) deviendra 12

La macro f (a, b) concatène ses arguments, g (a) les transforme en chaîne et h (a) est une macro auxiliaire pour g (a). Je pense que ça va sortir:

 12 f(1,2) 

La raison en est que la macro h (a) provoque le développement complet de son argument avant de le passer à g (a), tandis que g (a) prendra ses arguments littéralement sans les développer au préalable.

a ## b est la chaîne de caractères des littéraux a et b, donc f (1,2) est “12”

#a est le littéral de chaîne a, donc g (3) est “3”

## est l’opérateur de concaténation de macros. Ainsi, par exemple, f(foo,bar) serait équivalent à foobar .

   #define f (a, b) a ## b
   #define g (a) #a
   #define h (a) g (a)

Donc, ## combinez deux parties directement ensemble, quels que soient leurs types … Donnez-vous un exemple .. printf("%d\n",f(1,2)); vous obtenez 12, cela signifie ici que f (1,2) est 12 un entier.

     int a2 = 100;
     printf ("% d \ n", f (a, 2));

ici f (a, 2) est une étiquette. il pointe vers une étiquette dans votre contexte de code, s’il n’y a pas int a2 = 100 , vous obtenez des erreurs de compilation. Et #a transforme ce qui est est en chaîne … Et puis h(a) g(a) C’est très étrange .. Il semble que lorsque vous appelez h (a), il se transforme en a into g (a), premièrement, il interprète ce que est. alors, avant que vous puissiez g (a), a est transformé en f (a, b) = a ## b = 12