c++ macros with memory?

Question

Is it possible to define macros

write_foo(A);
and
read_foo();

so that:

WRITE_FOO(hello);

code_block_1;

READ_FOO();

code         


        

Answer 1

Not what you are actually asking for, but if WRITE_FOO was a definition you could get something similar (without context I will just reuse the names, even if they are not so clear on the intent):

#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 2

It is not possible since macro should not contain preprocessor directives.

Answer 3

Macros cannot redefine other macros, but you can do it manually.

#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

Unfortunately, the #define + #undef combination cannot be encapsulated in any other structure that I am aware of.

Answer 4

this is the sweet spot for tools like Cog that approach the problem of code generation from an intuitive programming approach using python. This is what would look like your code using it

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