Macros C++ avec mémoire?

Question

Est-il possible de définir des macros

write_foo(A); 
and 
read_foo(); 

de telle sorte que:

WRITE_FOO(hello); 

code_block_1; 

READ_FOO(); 

code_block_2; 

READ_FOO(); 

WRITE_FOO(world); 

code_block_3; 

READ_FOO(); 

code_block_4; 

READ_FOO(); 

étend ses activités:

code_block_1; 
hello; 
code_block_2; 
hello; 

code_boock_3; 
world; 
code_block_4; 
world; 

?

Merci!

Answer 1

Les macros ne peuvent pas redéfinir d'autres macros, mais vous pouvez le faire manuellement.

#define FOO hello 

FOO // expands to hello 

#undef FOO 
#define FOO world 

FOO // expands to world 

#undef FOO 
#define FOO blah 

FOO // expands to blah 

Malheureusement, la combinaison #define + #undef ne peut être encapsulé dans une autre structure que je suis au courant.

Answer 2

Ce n'est pas possible car la macro ne doit pas contenir de directives de préprocesseur.

Answer 3

pas ce que vous demandez en fait pour, mais si WRITE_FOO était une définition que vous pourriez obtenir quelque chose de similaire (sans contexte, je vais réutiliser les noms, même si elles ne sont pas si claires sur l'intention):

#define READ_FOO() WRITE_FOO 

#define WRITE_FOO hello 
code...[1] 
READ_FOO(); 
code...[2] 
#define WRITE_ROO world 
code...[3] 
READ_FOO(); 

// will expand to: 
code...[1] 
hello; 
code...[2] 
code...[3] 
world; 

Answer 4

c'est le sweet spot pour des outils tels que Cog qui approche le problème de génération de code à partir d'une approche de programmation intuitive en utilisant Python. C'est ce qui ressemblerait à votre code en l'utilisant

/*[[[cog 
# definitions ---- 
import cog 
Foo = '' 
def WriteFoo(value): 
    Foo = value 

def ReadFoo(): 
    cog.outl(' %s; ' % Foo) 

# generation --- 
WriteFoo('hello') 
]]]*/ 
//[[[end]]] 

some_code_block; 

/*[[[cog 
ReadFoo() ]]]*/ 
hello; 
//[[[end]]] 

some_other_blocK; 

/*[[[cog 
WriteFoo('world') 
ReadFoo() ]]]*/ 
world; 
//[[[end]]] 


last_block;