Errori, bug, domande - pagina 2866

Nuovo commento
 

Tutto è possibile, solo una macro deve essere aggiunta

#define  VALUE 10

MACRO( VALUE, VALUE2 )

#define  VALUE   VALUE2*2

void f( int i = VALUE ) { Print( i ); }
void OnStart()
{
        f();
}

Risultato: 20

 
A100:

Tutto è possibile, solo una macro deve essere aggiunta

Risultato: 20.

Questo è molto buono. Non sono bravo a indovinare i puzzle.

 
Vladimir Simakov:

Scusa, mi sono confuso mentre cercavo di spiegarmi)))

Un'altra volta:

Al momento della seconda definizione di VALUE, la macro VALUE non è definita, quindi VALUE è definito come

perché TMP era ed è ancora definito da VALUE.

Ma TMP, dopo la seconda definizione di VALORE, si espande a

(Qualcosa del genere))

Il preprocessore riempie semplicemente ciò che ha e non importa come e dove è definito. È per questo che bisogna fare attenzione. Esempio:

e ora aggiungiamo una cosa malvagia alla funzione, cioè un effetto collaterale

E questa è solo un'iscrizione, ma se il deposito dipendesse da questa funzione?

divertente) quando lo ottieni)

#define  VALUE 10        
#define  TMP VALUE       
#undef  VALUE     

Ho capito bene, dopo aver annullato la sostituzione, la prima linea non è più 10 e il secondo TMP è VALUE, ma non 10. Cioè la sostituzione è lontana dall'assegnazione.

 
Valeriy Yastremskiy:

divertente) quando lo ottieni)

Ho capito bene, dopo aver annullato la sostituzione, la prima linea non è più 10 e il secondo TMP è un VALORE, ma non 10. Cioè una sostituzione è lontana da un incarico.

Sì, una sostituzione è esattamente una sostituzione, uno a uno. Ma quando la macro VALUE è definita nel vostro codice (da non confondere con la direttiva del preprocessore), il preprocessore espande ulteriormente TMP->VALUE->10 e, in caso contrario, TMP->VALUE. In questo caso, le direttive del preprocessore non sono coinvolte nel codice stesso, non ci sono più quando viene compilato. Esempio:

#define  VALUE 10
#define  TMP VALUE

void OnStart()
{
   Print(TMP); //10
if (false){
   #undef  VALUE
   #define  VALUE 20
   Print(TMP);}
else Print(TMP); //20
}
 
Vladimir Simakov:

Sì. La sostituzione è esattamente la sostituzione, uno a uno. Semplicemente, quando la macro VALUE è definita nel vostro codice (da non confondere con le direttive del preprocessore), il preprocessore espanderà TMP->VALUE->10, e se no, TMP->VALUE. In questo caso, le direttive del preprocessore non sono coinvolte nel codice stesso, non ci sono più quando viene compilato. Esempio:

Sì, se commentate la seconda sostituzione VALUE 20, la dichiarazione della variabile VALUE non ci sarà più e il compilatore non la vedrà e la sgriderà)

 
A100:

Tutto è possibile, solo una macro deve essere aggiunta

Risultato: 20

Mi arrendo)))

Come si definisce? 

MACRO

?

 
Vladimir Simakov:

Mi arrendo)))

Come certi

?

Così in fretta? Non tutti gli specialisti hanno ancora aderito... Aspetteremo una settimana.

Suggerimento: anche questo funziona (ma la soluzione è leggermente diversa)

#define  VALUE1 10
#define  VALUE2 5

MACRO2( VALUE1, VALUE12 )
MACRO2( VALUE2, VALUE22 )

#define  VALUE1  VALUE12*2
#define  VALUE2  VALUE22*3

int f1( int i = VALUE1 ) { return i; }
int f2( int i = VALUE2 ) { return i; }
void OnStart()
{
        Print(f1(),":",f2());
}

Risultato: 20:15

 
Vladimir Simakov:

perché TMP era, ed è ancora, definito da VALUE.

È qui che entra in gioco la confutazione "dall'alto verso il basso".

Altrimenti TMP non sarebbe stato "come definito, quindi rimane definito", ma sarebbe stato precedentemente sostituito da 10 (a cui viene sostituito VALUE).

Quindi il preprocessore non sta elaborando il codice linea per linea. Quello che resta da capire è come.


@A100, se non ti dispiace, in poche parole.
Non abbastanza interessante da cercare su Google e leggere, ma abbastanza da chiedere.

Cosa c'è di sbagliato nella mia logica?

Ho immaginato che le stringhe siano analizzate in modo sequenziale. Quindi non c'è nessun valore indefinito a destra:

#define  VALUE 10       // VALUE = 10
#define  TMP VALUE      // TMP = 10
#undef  VALUE           // VALUE = EMPTY
#define  VALUE (TMP*2)  // TMP = 10, следовательно VALUE = 20
 
A100:

Suggerimento: anche questo funziona (ma la soluzione è leggermente diversa)

Quindi identico in azione a MACRO e MACRO2.

 
Andrey Khatimlianskii:

Cosa c'è di sbagliato nella mia logica?

#define  VALUE 10       // VALUE = 10
#define  TMP VALUE      // TMP = 10 VALUE
#undef  VALUE           // VALUE = EMPTY
#define  VALUE (TMP*2)  // TMP = 10 EMPTY, следовательно VALUE = 20 EMPTY
1...285928602861286228632864286528662867286828692870287128722873...3184
Nuovo commento