#Define VS variabile

Question

non riesco a capire che cosa è la differenza tra:

#define WIDTH 10 

e

int width = 10; 

Quali sono i vantaggi di utilizzare il primo o il secondo?

Answer 1

bene, c'è una grande differenza. È possibile modificare il valore di width, è possibile prendere il suo indirizzo, è possibile chiedere la sua dimensione e così via. Con WIDTH, verrà sostituito con una costante 10 ovunque, quindi l'espressione ++WIDTH non ha alcun senso. Oppure dall'altra parte, è possibile dichiarare un array con gli elementi WIDTH, mentre non è possibile dichiarare un array con gli elementi width.

Riassumendo: il valore di WIDTH è noto al momento della compilazione e non può essere modificato. Il compilatore non alloca memoria per WIDTH. Al contrario, width è una variabile con iniziale valore 10, i suoi ulteriori valori non sono noti al momento della compilazione; la variabile ottiene la sua memoria dal compilatore.

Answer 2

è una macro che verrà sostituita con il valore (10) dal preprocessor mentre width è una variabile.

Quando # definisce una macro (come WIDTH qui), il preprocessore eseguirà semplicemente una sostituzione di testo prima che il programma passi al compilatore. Ovunque tu abbia usato WIDTH nel tuo codice, sarà semplicemente sostituito con 10.

ma quando lo fai int width=10, la variabile è vivo

Answer 3

Prima un breve quadro: prima di ottenere compilato, un file C è pre-elaborati. Il preprocessore controlla per le dichiarazioni #include e #define.

Nel tuo caso, che #define dichiarazione dice al pre-processore cambiare ogni stringa WIDTH nel codice sorgente con la stringa 10. Quando il file ottiene compilato nel passaggio successivo, ogni occorrenza di WIDTH sarà di fatto 10. Ora, la differenza tra

#define WIDTH 10 

e

int width = 10; 

è che il primo può essere visto come un valore constant, mentre il secondo è una normale variabile il cui valore può essere modificato.

Answer 4

Qual è la differenza tra due?

Il primo è un Macro mentre il secondo è una dichiarazione variabili.

#define WIDTH 10 è un preprocessor directive che consente di specificare un nome (WIDTH) e il suo testo di sostituzione (10). Il preprocessore analizza il file sorgente e ogni occorrenza del nome viene sostituita dal testo associato. Il compilatore non vede mai realmente un nome di macro, quello che vede è il testo sostituito.

La dichiarazione della variabile viene valutata dal compilatore stesso. Indica al compilatore di dichiarare una variabile denominata width e del tipo int e inoltre la inizializza con un valore 10.
Il compilatore conosce questa variabile con il proprio nome width.

Quale preferisci? E perché?

In genere, è consigliabile utilizzare variabili costanti di tempo costante su #define. Così tua dichiarazione di variabile dovrebbe essere:

const int width = 10; 

Ci sono una serie di ragioni per la selezione di compilazione costanti di tempo nel corso #define, vale a dire:

Ambito meccanismo basato:

Il campo di applicazione #define è limitato al file in cui è definito. Quindi, #defines che vengono creati in un file sorgente sono NON disponibili in un file sorgente diverso. In breve, gli #define s non rispettano gli ambiti. Si noti che le variabili const possono essere con scope. Osservano tutte le regole di ambito.

---

Evitare numeri magici strane durante errori di compilazione:

Se si utilizza #define quelli sono sostituiti dal pre-processore al momento della precompilazione Quindi, se si riceve un errore durante la compilazione, è sarà confuso perché il messaggio di errore non rimanda al nome della macro ma al valore e apparirà un valore improvviso, e si perderebbe molto tempo rintracciandolo nel codice.

---

Facilità di debug:

anche per stessi motivi di cui al # 2, durante il debug #define avrebbe fornito alcun aiuto davvero.

Answer 5

Uno #define è gestita dal preprocessore, se ritrovamenti WIDTH nel codice sorgente e lo sostituisce con 10, non fa altro cambio di base tra le altre cose, l'altro int width = 10; è gestita dal compilatore, questo creerà voci la tabella di ricerca, genera binari per allocare memoria sufficiente nello stack, a seconda di dove si definisce, e copia il valore 10 in quella posizione di memoria.

Così uno è niente di più di un'etichetta per una costante, l'altro è una variabile in fase di esecuzione.

È possibile utilizzare un preprocessore per l'esecuzione più veloce, dal momento che le variabili devono essere allocato sullo stack, a costo di non essere mutabile in fase di esecuzione.

Di solito si utilizzano i preprocessori per le cose che non devono essere modificate in fase di esecuzione, ma attenzione ai preprocessori può essere un po 'complicato eseguire il debug, dal momento che possono effettivamente manipolare il codice sorgente prima di passare al compilatore, che conduce a bug molto sottili, che possono o non possono essere evidenti nell'esaminare il codice sorgente.