Changer une macro à l’exécution en C

J’ai une macro définie. Mais je dois changer cette valeur au moment de l’exécution en fonction d’une condition. Comment puis-je implémenter cela?

Les macros sont remplacées par le préprocesseur par leur valeur avant même que votre fichier source ne soit compilé. Il est impossible que vous puissiez modifier la valeur de la macro au moment de l’exécution.

Si vous pouviez expliquer un peu plus l’objective que vous essayez d’atteindre, il existe sans doute une autre façon de résoudre votre problème, qui ne comprend pas les macros.

Vous ne pouvez pas modifier la macro elle-même, c’est-à-dire ce à quoi elle se développe, mais vous pouvez éventuellement modifier la valeur d’une expression impliquant la macro. Pour un exemple très stupide:

#include  #define UNCHANGEABLE_VALUE 5 #define CHANGEABLE_VALUE foo int foo = 5; int main() { printf("%d %d\n", UNCHANGEABLE_VALUE, CHANGEABLE_VALUE); CHANGEABLE_VALUE = 10; printf("%d %d\n", UNCHANGEABLE_VALUE, CHANGEABLE_VALUE); } 

La réponse à votre question dépend donc du type d’effet que vous souhaitez que votre modification ait sur le code qui utilise la macro.

Bien sûr, 5 est une constante de compilation, contrairement à foo . Cela ne fonctionne donc pas si vous envisagez d’utiliser CHANGEABLE_VALUE comme CHANGEABLE_VALUE de case ou autre.

N’oubliez pas qu’il y a deux étapes (en réalité plus) de traduction de la source C. Dans le premier (des deux qui nous intéressent), les macros sont étendues. Une fois que tout est fait, le programme est “analysé syntaxiquement et sémantiquement”, comme le dit 5.1.1.2/2. Ces deux étapes sont souvent appelées “pré-traitement” et “compilation” (bien que de manière ambiguë, l’ensemble du processus de traduction est également souvent appelé “compilation”). Ils peuvent même être implémentés par des programmes séparés, le “compilateur” exécutant le “préprocesseur” selon les besoins, avant de faire autre chose. Le runtime est donc beaucoup trop tard pour essayer de revenir en arrière et de modifier l’extension d’une macro.

Tu ne peux pas. Les pré-processeurs développent les macros, ce qui se produit même avant la compilation du code. C’est un remplacement purement textuel.

Si vous devez modifier quelque chose au moment de l’exécution, remplacez simplement votre macro par un appel de fonction réel.

Tu ne peux pas.

Lorsqu’une macro est résolue par le pré-processeur avant la compilation elle-même, son contenu est directement copié à l’endroit où vous l’utilisez.

Vous pouvez toujours utiliser des parameters pour insérer une instruction conditionnelle en fonction de ce que vous voulez ou utiliser une variable accessible par call-scope.

Si vous souhaitez modifier une seule valeur, utilisez mieux la variable de scope globale, même si un tel comportement est découragé. (comme l’utilisation intensive de la macro)

Selon ce que vous voulez faire, vous pouvez le faire de plusieurs façons.

Variable globale au lieu de macro

 // someincludefile.h extern static int foo; // someincludefile.c static int foo = 5; // someotherfile.c #include "someincludefile.h" printf("%d\n", foo); // >> 5 foo = -5; printf("%d\n", foo); // >> -5 

Condition que vous pouvez basculer

 // someincludefile.h extern static int condition; #define FOO1 (5) #define FOO2 (-5) #define FOO (condition ? (FOO1) : (FOO2)) // someincludefile.c static int condition = 1; // someotherfile.c #include "someincludefile.h" printf("%d\n", FOO); // >> 5 condition = 0; printf("%d\n", FOO); // >> -5 

Condition évaluée localement et dynamicment

 // someincludefile.h #define CONDITION (bar >= 0) #define FOO1 (5) #define FOO2 (-5) #define FOO ((CONDITION) ? (FOO1) : (FOO2)) // someotherfile.c #include "someincludefile.h" int bar = 1; printf("%d\n", FOO); // >> 5 bar = -1; printf("%d\n", FOO); // >> -5 

Dans ce dernier cas, la CONDITION sera évaluée comme si son code se trouvait dans votre scope locale. Vous pouvez donc utiliser des variables locales et / ou des parameters, mais vous pouvez également utiliser des variables globales si vous le souhaitez.