[C] tricks avec les macros

[ark]

Yop,

bon, aujourd'hui je viens de découvrir un truc sympathique en C, et particulièrement avec les macros, je ne m'y étais jamais vraiment attardé, mais c'est quand même vraiment puissant comme truc.

bref, trêves de bavardages, je vous laisse avec du code :

Code C :


#define STR_NX(A) #A
#define STR(A) STR_NX(A)

#define CCAT_NX(A, B) A ## B
#define CCAT(A, B) CCAT_NX(A, B)

#include <stdio.h>

int main (void) {
  puts(STR(foo));
  puts(STR(bar));
  puts(STR("hello world"));
  puts(STR(CCAT(foo, bar)));
  return 0;
}
 

Compilez, exécutez, admirez!!

Bon, du coup, peut être que quelques explications s'imposent!

Dans la première macro le #A permet d'étendre la macro, c'est a dire qu'on va récupérer son symbole, globalement, ça permet de la transformer en string!!

Ensuite, dans 3eme macro : #define CCAT_NX(A, B) A ## B, le symbole A ## B permet tout simplement de concatener deux macros non étendues

Les deux autre macros, permettront ensuite de pouvoir utiliser les autre macros en les enchainant, comme on peut le voir dans le puts(STR(CCAT(foo, bar)));
Si on ne les définit pas, cela peut nous permettre d'afficher directement le symbole d'une macro, en faisant par exemple:

Code C :


#define foo "bar"
#define STR_NX(A) #A

#include <stdio.h>

int main (void) {
  puts(STR_NX(foo));
  return 0;
}
 

Voila, voila, si vous connaissez d'autres tricks avec les macros, n'hésitez pas ! ;)

[b0fh]

Hello,

Qu'y-a-il comme applications concrètes de cette technique ?

J'en connais deux. La première pour le debugging:

Code C :

#define ASSERT(T) ((T) || fprintf(stderr, "Warning: " #T " failed\n"))

Et la deuxième comme template du pauvre, par exemple des structures polymorphiques sur leurs types:

Code C :


#define DECLARE_LINKED_LIST_OF(t) struct { t item; struct list_of_##t *next } list_of_##t;
 

[darcosion]

J'ai remarqué une chose amusant même si je ne l'ai pas totalement saisie.

Lorsque l'on écrit

Code :

puts(STR(CCAT(l,olol)));

, il n'y a pas de soucis, on obtient un "lolol", mais lorsque l'on fait

Code :

puts(STR_NX(CCAT(l,olol)));

, là on obtient "CCAT(l, olol)".

J'aurais bien une expliquation : entre deux macro, il y a un temps d'interprétation qui permet de faire pour un STR : CCAT(STR_NX(l),STR_NX(olol)).

Chose qui n'est pas possible avec un STR_NX.

[ark]

bah je dirais que : étape 1
STR(CCAT(l, olol)) --> STR_NX(CCAT_NX(l, olol))

étape 2:
#lolol --> "lolol"

Et dans le deuxieme cas:

étape 1:
STR_NX(CCAT(l, olol)) --> #CCAT_NX(l, olol)

étape 2:
#CCAT_NX(l, olol) --> "CCAT_NX(l, olol)"

[darcosion]

Hey, je reviens vers vous car j'ai trouvé une autre utilisation des macro via ce tuto.

Donc si on fait :

Code :

#define xstr(s) str(s)
#define str(s) #s

Puis

Code :

scanf("%"xstr(TAILLE)"s", tab);

Cela peut résoudre des problèmes de tails liés à la fonction scanf().

[gruik]

hmm.. il doit falloir rajouter un -1 quelque part (ou un +1 à l'allocation), sinon on a un off-by-one là justement

quand le tableau est fixe -mettons char[100]- on aura meilleur compte de mettre explicitement/en dur %99s dans le scanf

quand le tableau est dynamique, la stratégie à adopter peut varier,
- soit reposer sur le switch %m de *scanf() (GNU !) qui va allouer tout seul comme un grand ce dont on a besoin
- soit faire du traitement bufferisé avec des tampons de taille fixe
- soit brider carrément la taille des données saisies/couper tout ce qui dépasse

[darcosion]

Okay, c'est bon à savoir.

Sinon, en fouillant du coté de la lib windows.h, j'ai trouvé une autre macro nommé MAX_PATH qui permet d'allouer à une chaine de caractère la taille maximale d'un path (256 caractères).

[supersnail]

Enfin là c'est juste un define qui rend "humainement lisible" une constante "magique", c'est pas un trick en soi

D'ailleurs, cette constante me semble un peu outdated, normalement le noyau NT peut gérer des paths de longueur arbitraires, sûrement une relique antique datant du moment où windows était basé sur MS-DOS et laissé comme ça pour des raisons obscures de rétro-compatibilité.

Edit: apparament cette constante est toujours d'actualité pour les applications Win32, il semblerait qu'il s'agisse là d'une limitation du sous-système Win32 et non du noyau NT (à noter qu'il est possible de faire sauter cette limitation en travaillant avec les API Unicode et en rajoutant le préfixe "\?\" devant le chemin mais bon...). Pour un peu plus de précisions, voir http://stackoverflow.com/questions/28257...n-max-path. Bref le sous-système win32 devrait être remplacé par un truc un peu plus moderne imo :]