c++ macros with memory?

问题:

Is it possible to define macros

write_foo(A);
and
read_foo();

so that:

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

expands into:

code_block_1;
hello;
code_block_2;
hello;

code_boock_3;
world;
code_block_4;
world;

?

Thanks!

回答1:

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.

回答2:

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

回答3:

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;

回答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;