2010-03-24 33 views
7

E 'possibile definire macroMacro C++ con memoria?

write_foo(A); 
and 
read_foo(); 

in modo che:

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

espande in:

code_block_1; 
hello; 
code_block_2; 
hello; 

code_boock_3; 
world; 
code_block_4; 
world; 

?

Grazie!

+0

Probabilmente, usando #pragma push/pop e ridefinendo il a 'DEFINE'. Non so C/C++, per aiutarti di più. – leppie

+4

Ogni volta che qualcuno fa qualcosa di complesso con una MACRO, devo chiedere "perché?". –

risposta

4

I macro non possono ridefinire altre macro, ma è possibile farlo 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 

Purtroppo, la combinazione #define + #undef non può essere incapsulato in qualsiasi altra struttura che io sono a conoscenza.

+1

Ovviamente ciò significherebbe che l'intestazione non contiene guardie di intestazione ... –

+0

Ma questo è ok fintanto che '# undef' READ_FOO. –

+0

Indovina cosa! [Qualcuno ha provato questo] (http://stackoverflow.com/questions/9526096/c-macro-with-memory) e non funziona! – Shahbaz

4

Non è possibile poiché la macro non deve contenere direttive del preprocessore.

2

Non è quello che sono in realtà chiedono, ma se WRITE_FOO era una definizione che si potrebbe ottenere qualcosa di simile (senza contesto mi limiterò a riutilizzare i nomi, anche se non sono così chiare sull'intento):

#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; 
0

questo è il punto ideale per strumenti come Cog che affrontano il problema della generazione del codice da un approccio di programmazione intuitivo che utilizza python. Questo è quello che sembrerebbe il tuo codice usando

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