macros C++ con memoria?

Question

¿Es posible definir macros

write_foo(A); 
and 
read_foo(); 

de modo 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(); 

se expande en:

code_block_1; 
hello; 
code_block_2; 
hello; 

code_boock_3; 
world; 
code_block_4; 
world; 

?

Gracias!

Answer 1

Las macros no pueden redefinir otras macros, pero puede hacerlo manualmente.

#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 

Desafortunadamente, la combinación #define + #undef no puede ser encapsulada en cualquier otra estructura que yo sepa.

Answer 2

No es posible porque la macro no debe contener directivas de preprocesador.

Answer 3

No es lo que en realidad están pidiendo, pero si WRITE_FOO era una definición que usted podría conseguir algo similar (sin contexto simplemente voy a volver a utilizar los nombres, aunque no son tan claras de la intención):

#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

este es el punto ideal para herramientas como Cog que abordan el problema de la generación de código desde un enfoque de programación intuitiva usando python. Esto es lo que se vería como el código que lo usa

/*[[[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;