Errori, bug, domande - pagina 2865

[Vladimir Pastushak]

È impossibile creare un nuovo prodotto per il mercato, dice errore 500.

Il prodotto è stato creato e controllato, dice che è stato pubblicato, ma quando si clicca sul link si ottiene una risposta di 500.

[Andrey Khatimlianskii]

fxsaber:

Funziona dall'alto verso il basso come sostituzione del testo. Cioè "TMP" sarà sostituito da "VALUE".

Vladimir Simakov:

Questo non è un compilatore - è un preprocessore)

si trasforma in

e il VALORE non è definito.

Come dovrebbe funzionare undef?

[fxsaber]

Andrey Khatimlianskii:

Come dovrebbe funzionare undef?

Fino a questo punto, c'è una "sostituzione di testo" in corso.

[Valeriy Yastremskiy]

Vladimir Simakov:

Non è un compilatore - è un preprocessore)

si trasforma in

, e il VALORE è indefinito.

#define  VALUE (VALUE*2)

Ho capito bene, il tipo di valore VALUE*2 è const ed è legato alla sostituzione stessa, cioè il VALUE è anche una costante. Il compilatore crea due costanti.

Se è così, deve creare una nuova sostituzione.

#define  VALUE1 (VALUE*2)

#define  VALUE VALUE1

E non è corretto se VALUE sopra il codice è stato definito come una costante.

[Andrey Khatimlianskii]

fxsaber:

Fino a questo punto c'è una "sostituzione di testo" in corso.

Non corrisponde, cambia TMP inVALUE nella linea "#define VALUE (TMP*2)" che è dopo.

[fxsaber]

Andrey Khatimlianskii:

Non quadra, cambia TMP inVALUE nella linea "#define VALUE (TMP*2)" che è dopo.

#define  MACROS TEXT
 // В этом интервале везде идет замена в исходнике MACROS на TEXT, как делалось бы в текстовом редакторе.
#undef  MACROS

E così continua la sostituzione fino a quando tutte le sostituzioni sono complete.

[Andrey Khatimlianskii]

fxsaber:
E così le sostituzioni continuano fino alla fine.

C'è un codice:

#define  VALUE 10       // 
#define  TMP VALUE      // 
#undef  VALUE           // 
#define  VALUE (TMP*2)  // 

La prima sostituzione cambia VALUE in 10 in tutto il codice fino a #undef VALUE, lasciando questo:

#define  TMP 10
#define  VALUE (TMP*2)

La prossima sostituzione cambia il TMP in 10. Si scopre che

#define  VALUE (10*2)

Dove sto sbagliando?

[Vladimir Simakov]

Andrey Khatimlianskii:

C'è un codice:

La prima sostituzione cambia VALUE in 10 in tutto il codice fino a #undef VALUE, lasciando questo:

La prossima sostituzione cambia il TMP in 10. Si scopre che

Cosa sto facendo di sbagliato?

Non è 10 che viene sostituito a TMP, è il VALORE, ma se il VALORE è definito (il che è una rottura di palle), è 10.

Guarda questo passo per passo:

#define  VALUE 10        
#define  TMP VALUE       
#undef  VALUE            
#define  VALUE (TMP*2)

void OnStart(void)
{
   Print(VALUE)
}

Il preprocessore inserisce fedelmente Print

Print((TMP*2));

e poi, di nuovo senza trucchi, sostituisce cosa? Giusto:

Print((VALUE*2));

e poi cancella tutte le direttive del preprocessore e solo dopo il compilatore ottiene questo:

void OnStart(void)
{
   Print((VALUE*2));
}

[Andrey Khatimlianskii]

Vladimir Simakov:

TMP non è 10, ma VALUE è sostituito a TMP, e poi se VALUE è definito (il che è un problema), è 10

Guarda questo passo per passo:

Il preprocessore inserisce fedelmente Print

e poi, di nuovo senza trucchi, sostituisce cosa? Giusto:

e poi cancella tutte le direttive del preprocessore e solo dopo il compilatore ottiene questo:

Questo non si chiama "top-down".

[Vladimir Simakov]

Andrey Khatimlianskii:

Non si chiama top-down.

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

Un'altra volta:

#define  VALUE 10        
#define  TMP VALUE       
#undef  VALUE            
#define  VALUE (TMP*2)

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

(VALUE*2)

perché TMP era ed è ancora definito da VALUE.

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

(TMP*2)

(Qualcosa del genere))

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

#define  min(A,B) ((A)<(B)?(A):(B))

long Foo(int x) {return x*x;}

void OnStart(void)
{
   int a=500,
       b=20;
   Print(min(500,Foo(b))); //400
}

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

#define  min(A,B) ((A)<(B)?(A):(B))

long Foo(int x){
   Print("Увидивший это второй раз - нубяра vulgaris");
   return x*x;}

void OnStart(void)
{
   int a=500,
       b=20;
   Print(min(500,Foo(b)));
}

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