Modifica di una macro in fase di esecuzione in C

Ho una macro definita. Ma ho bisogno di cambiare questo valore in fase di esecuzione a seconda di una condizione. Come posso implementarlo?

Le macro vengono sostituite dal preprocessore in base al loro valore prima che il file sorgente venga compilato. Non è ansible che tu possa modificare il valore della macro in fase di esecuzione.

Se potessi spiegare un po ‘di più sull’objective che stai cercando di realizzare senza dubbio c’è un altro modo di risolvere il tuo problema che non include le macro.

Non è ansible modificare la macro stessa, ovvero a cosa si espande, ma potenzialmente è ansible modificare il valore di un’espressione che coinvolge la macro. Per un esempio molto sciocco:

#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); } 

Quindi la risposta alla tua domanda dipende dal tipo di effetto che vuoi che la tua modifica abbia sul codice che utilizza la macro.

Ovviamente 5 è una costante in fase di compilazione, mentre foo no, quindi questo non funziona se hai pianificato di usare CHANGEABLE_VALUE come etichetta del case o altro.

Ricorda che ci sono due (in realtà più) fasi di traduzione della sorgente C. Nel primo (dei due ci interessa), le macro vengono espanse. Una volta fatto tutto ciò, il programma è “sintatticamente e semanticamente analizzato”, come dice 5.1.1.2/2. Questi due passaggi vengono spesso definiti “pre-elaborazione” e “compilazione” (anche se ambiguamente, l’intero processo di traduzione viene spesso definito “compilazione”). Possono anche essere implementati da programmi separati, con il “compilatore” che esegue il “preprocessore” come richiesto, prima di fare qualsiasi altra cosa. Quindi il runtime è troppo, troppo tardi per provare a tornare indietro e cambiare ciò a cui una macro si espande.

Non puoi Le macro vengono espanse dal preprocessore , che avviene anche prima della compilazione del codice. È una sostituzione puramente testuale.

Se è necessario modificare qualcosa in fase di esecuzione, è sufficiente sostituire la macro con una chiamata di funzione reale.

Non puoi

Come una macro viene risolta dal preprocessore prima della compilazione stessa, il suo contenuto viene copiato direttamente dove lo si utilizza.

È ancora ansible utilizzare i parametri per inserire un’istruzione condizionale in base a ciò che si desidera o utilizzare una variabile accessibile di tipo call-scope.

Se si desidera modificare un singolo valore, utilizzare la variabile dell’oscilloscopio globale, anche se tale comportamento è sconsigliato. (come l’uso intensivo della macro)

A seconda di cosa vuoi fare, potresti farlo in diversi modi.

Variabile globale anziché 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 

Condizione che puoi triggersre

 // 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 

Condizione valutata localmente e dynamicmente

 // 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 

In quest’ultimo, la CONDITION verrà valutata come se il codice fosse nel tuo scope locale, quindi puoi usare variabili locali e / o parametri al suo interno, ma puoi anche usare variabili globali se vuoi.