Articles of macros

quel est le sens de cette macro C?

Voici une macro peut calculer le nombre d’arguments. et le code comme: #define Y_TUPLE_SIZE_II(__args) Y_TUPLE_SIZE_I __args #define Y_TUPLE_SIZE_PREFIX__Y_TUPLE_SIZE_POSTFIX ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,0 #define Y_TUPLE_SIZE_I(__p0,__p1,__p2,__p3,__p4,__p5,__p6,__p7,__p8,__p9,__p10,__p11,__p12,__p13,__p14,__p15,__p16,__p17,__p18,__p19,__p20,__p21,__p22,__p23,__p24,__p25,__p26,__p27,__p28,__p29,__p30,__p31,__n,…) __n #define MPL_ARGS_SIZE(…) Y_TUPLE_SIZE_II((Y_TUPLE_SIZE_PREFIX_ ## __VA_ARGS__ ## _Y_TUPLE_SIZE_POSTFIX,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0)) // the running result ————————————— MPL_ARGS_SIZE(a,b,c,d,e,f,g)==7 MPL_ARGS_SIZE(a,b,c,d)==4 comment comprendre #define Y_TUPLE_SIZE_PREFIX__Y_TUPLE_SIZE_POSTFIX ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,0 et Y_TUPLE_SIZE_PREFIX_ ## __VA_ARGS__ ## _Y_TUPLE_SIZE_POSTFIX ? En passant, je connais l’utilisation de ## […]

C préprocesseur: évaluer la macro à l’avance

Considérez la configuration suivante: ah #define A 5 #define BA #undef A #define A 3 ac #include “ah” #include int main() { printf(“%d\n”, B); return 0; } Alors que cela imprime très raisonnablement 3, y a-t-il un moyen de le faire imprimer 5, c’est-à-dire que la substitution de 5 à A déjà à la ligne […]

offset de compilation

Existe-t-il un moyen de trouver le décalage d’un membre d’une structure au moment de la compilation? Je souhaite créer une constante contenant le décalage d’un membre de la structure. Dans le code suivant, la macro offsetof() fonctionne dans la première instruction printf . Cependant, l’utilisation de la ligne 10 pour déclarer ofs génère l’erreur: “Ne […]

Quelle est la valeur __STDC_VERSION__ pour C11?

Je sais que les compilateurs utilisent __STDC__ pour indiquer qu’un compilateur est la norme C et que, à partir de là, vous pouvez utiliser __STDC_VERSION__ pour déterminer le niveau de la norme que vous utilisez. Je sais aussi que C90 n’avait aucune valeur, l’amendement C90 1 portait 199401L et le C99 199901L . Le dernier […]

Expansion de macro pré-processeur

J’essaie de faire (ce que j’aurais pensé) était une simple expansion macro #define CLEAR_DIGIT(a,b) iconMap[a] &= ~(b) #define R1 4, 16 CLEAR_DIGIT(R1); Maintenant, je m’attendrais à ce que cela s’étende à CLEAR_DIGIT (4,16), lequel se développe à iconMap [4] & = ~ 16 Cependant, ce n’est pas … Si je fais de CLEAR_DIGIT une fonction: […]

Pourquoi -lm n’est-il pas nécessaire dans certains cas lors de la compilation et de la liaison de code C?

J’ai un exemple de fichier ici: #include #include int main(){ printf(“%f\n”, log(10)); } Quand je le comstack avec gcc sample.c -oa ça marche très bien. Je peux l’exécuter avec ./a et il produit la sortie 2.302585 comme prévu. Pourtant, quand mon fichier ressemble à ceci: #include #include int main(){ double a = 10; printf(“%f\n”, log(a)); […]

Comment passer le résultat d’une macro à une autre macro?

J’ai deux macros dans mon code C qui m’aide à composer le nom de certaines variables. A titre d’exemple, considérons les éléments suivants: #define MACROA(name) A_##name #define MACROB(name) B_##name void *MACROB(MACROA(object)); Donc, j’essaie de déclarer une variable appelée B_A_object . Cependant, cela ne fonctionne pas et le compilateur me lance le message: object.c:27:21: error: a […]

macro définition

J’ai essayé de définir une macro fonctionnant comme ci-dessous. L’appel 1 n’a pas de problème, mais l’appel 2 a provoqué une erreur du compilateur car le 3ème argument n’est pas disponible. Comment définir une macro prenant en charge à la fois les appels 1 et 2? #define RDF_LOG(dbglevel, fmt, …) (rdfDBG(dbglevel, ” ” fmt, __VA_ARGS__)) […]

Jetons de préprocesseur valides dans la concaténation de macros

J’ai essayé de comprendre les macros dans c en utilisant l’opérateur de préprocesseur de concaténation ## mais je me suis rendu compte que j’ai un problème avec les jetons. Je pensais que c’était facile, mais en pratique, ce n’est pas le cas. La concaténation sert donc à concaténer deux jetons pour créer un nouveau jeton. […]

Que fait l’opérateur # dans les macros?

#include #define foo(x, y) #x #y int main() { printf(“%s\n”, foo(k, l)); return 0; } Sortie: kl Je sais que ## fait la concaténation. À la sortie, il semble que # également la concaténation. Ai-je raison? Si j’ai raison, quelle est la différence entre l’opérateur ## et l’opérateur # ?