differenze tra define e const
stefano
velocita' di esecuzione tra una define e una costante dichiarata con
l'attributo const
quello che ho capito e' che una define e' una direttiva al preprocessore,
quindi in fase di precompilazione viene "espansa" cioe' dove e' utilizzata
questa define viene sostituito il suo valore dichiarato nella define
ma a livello di velocita' di escuzione del task cambia qualcosa???
su i manuali C non ho trovato molto, quindi lo chiedo a voi: secondo me sia
le define che le const vengono caricate, quando viene caricato il programma,
nella sezione dati generale della ram... se e' cosi' sia a livello di
dimensioni dell'eseguibile che di velocita' di esecuzione non cambia niente,
ma allora qual'e' questa differenza tra una define e una costante dichiarata
con const???
ciao e grazie in anticipo!!!
Angelo Paolitto
> ciao, non riesco a capire se esiste una differenza sostanziale a livello di
> velocita' di esecuzione tra una define e una costante dichiarata con
> l'attributo const
> quello che ho capito e' che una define e' una direttiva al preprocessore,
> quindi in fase di precompilazione viene "espansa" cioe' dove e' utilizzata
> questa define viene sostituito il suo valore dichiarato nella define
> ma a livello di velocita' di escuzione del task cambia qualcosa???
Magari su un P4 a 2GHz...
Quanto definito con una "#define" (e scusate il bisticcio di parole) viene
sostituito dal preprocessore ogni volta che la macro viene incontrata.
#define PIPPO 4
non dara' luogo alla creazione di una variabile di memoria di nome PIPPO,
Una istruzione del tipo
var2 = var1 + PIPPO;
verra' tradotta dal compilatore in
mov eax, DWORD PTR _var1$[ebp]
add eax, 4
mov DWORD PTR _var2$[ebp], eax
add eax, 4 indica che NON viene fatto nessun accesso in memoria per
recuperare il valore 4: questo e' codificato all'interno dell'istruzione.
una istruzione del tipo
var2 = var1 + constVar;
mov eax, DWORD PTR _var1$[ebp]
add eax, DWORD PTR _constVar$[ebp]
mov DWORD PTR _var2$[ebp], eax
DWORD PTR _constVar$[ebp] indica che viene fatto un accesso ad
un indirizzo di memoria per recuperare il valore 4. Gli accessi
in memoria sono costosi dal punto di vista dei tempi di accesso.
Ad occhio l'uso della macro velocizza il programma. Se pero' si considera
che il codice assembler e' stato generato senza nessuna ottimizzazione
e che usando le ottimizzazioni il codice generato potrebbe essere lo stesso
sia per la macro che con la variabile const, che la velocita' di esecuzione
in un ambiente multitask dipende dalla quantita' di processi attivi, che
nei sistemi moderni ci sono 1 o piu' livelli di cache delle istruzioni e
dei dati, ecc., ecc., ecc... Se ne deduce che domandarsi se un programma
e' piu' veloce usando le macro o le const e' quasi privo di senso.
> su i manuali C non ho trovato molto,
Forse perche' non dipende dal "C"?
> ma allora qual'e' questa differenza tra una define e una costante
> dichiarata con const???
Che una (se proprio sei in cerca di rogne) puoi anche modificarla e
l'altra no?
C:\>iao Angelo
--
questo articolo e` stato inviato via web dal servizio gratuito
http://www.newsland.it/news segnala gli abusi ad ab...@newsland.it
Lanugo of the Wandering Souls
Il compilatore che uso io ottimizzando sostiuisce automaticamente anche i
valori const (essendo costante, a tempo di compilazione si puo' prevedere
che valore avra' la variabile). E credo che se non prendo l'indirizzo si
variabili definite const, in effetti non le allochi nemmeno. Di conseguenza,
in gran parte dei casi non esistono differenze di velocita' tra una const ed
un define.
> > ma allora qual'e' questa differenza tra una define e una costante
> > dichiarata con const???
>
> Che una (se proprio sei in cerca di rogne) puoi anche modificarla e
> l'altra no?
Di una puoi prendere l'indirizzo...
Lanugo
Azimuth
> > Che una (se proprio sei in cerca di rogne) puoi anche modificarla e
> > l'altra no?
> Di una puoi prendere l'indirizzo...
... solo pero' se il puntatore e' a un valore "const":
const int pippo = 100;
...
int * pluto = & pippo; /* ERRORE! (O, almeno, un WARNING grosso quanto una
casa!) */
const int * pluto = & pippo; /* OK! */
Raffaele Castagno
"stefano" <vbst...@tiscali.it> ha scritto nel messaggio
news:ao4qis$gj2$1...@lacerta.tiscalinet.it...
> ciao, non riesco a capire se esiste una differenza sostanziale a livello
di
> velocita' di esecuzione tra una define e una costante dichiarata con
> l'attributo const
>
ora credo di averlo capito pure io...con il define, il preprocessore
sostituisce ad ogni occorrenza della costante il suo valore simbolico. con
const rimane il nome della costante, solo che non può essere modificato il
suo valore.
"giusto prof?"
Raffaele
Zaza
> > Ad occhio l'uso della macro velocizza il programma.
>
> Il compilatore che uso io ottimizzando sostiuisce automaticamente anche i
> valori const (essendo costante, a tempo di compilazione si puo' prevedere
> che valore avra' la variabile).
E' se hai un blocco di istruzioni contenente
const int m = 5;
int array[m];
che tipo di allocazione da ad array? Ovvero, risolve tutto a run-time
secondo il normale modello dei VLA, oppure
alloca array staticamente a 5 (comportamento non standard)?
Ciao.
Lanugo of the Wandering Souls
> const int m = 5;
> int array[m];
> che tipo di allocazione da ad array?
Nel C vecchio stile (non so in C99) la dimensione degli array deve essere
nota a compile-time. m e' costante, direi che la dimensione e' nota a
compile-time e non dovrebbero esserci problemi. Poi ripeto: quello che ho
scritto nel mio messaggio precedente e' quello che fa il mio compilatore.
Non so bene cosa preveda lo standard a riguardo.
>Ovvero, risolve tutto a run-time
> secondo il normale modello dei VLA, oppure
> alloca array staticamente a 5 (comportamento non standard)?
Allocarlo staticamente a 5 mi pare un'assunzione lecita da parte del
compilatore (lo so che si puo' provare a modificare il valore di una const
truschinando con cast e robetta varia, ma mi pare che il risultato sia
undefined).
Da qualche parte ho una draft dello standard per il C89, magari dopo
controllo (influenza permettendo).
Saluti,
Lanugo
Angelo Paolitto
> ... con
> const rimane il nome della costante, solo che non può essere modificato il
> suo valore.
Non e' detto: e' un undefined behavior (significa che il risultato
dell'operazione dipende dal compilatore).
Ad es. gcc ti permette di modificare il valore di una variabile dichiarata
const (anche se un warning te lo segnala), che sia intelligente farlo e'
tutto da dimostrare. :-)
Raffaele Castagno
"Angelo Paolitto" <angelo....@tiscalinet.it> ha scritto nel messaggio
news:aoeb94$ngv$1...@news.newsland.it...
> Raffaele Castagno wrote:
>
> > ... con
> > const rimane il nome della costante, solo che non può essere modificato
il
> > suo valore.
>
> Non e' detto: e' un undefined behavior (significa che il risultato
> dell'operazione dipende dal compilatore).
si, intendevo che in teoria non si può modificare...poi si sa che tra teoria
e pratica ci passa un bue di traverso....
Raffaele
Rosario Ianuale
"Raffaele Castagno" <arago...@hotmail.SIGILLO.com> ha scritto nel
messaggio news:aoevrb$mmd$1...@lacerta.tiscalinet.it...
animali... :-))
>
> Raffaele
>
>
Saluti
Rosario Ianuale
Marco Sarti
news:aoevrb$mmd$1...@lacerta.tiscalinet.it:
> si, intendevo che in teoria non si può modificare...poi si sa che tra
> teoria e pratica ci passa un bue di traverso....
Beh, i seguente codice:
int *s;
const int c = 2;
s = (int *)&c;
*s= 4;
cout << c;
sia il gcc (win32) che il vc lo compilano senza fiatare, ma in entrambi i
casi la variabile const resiste stoicamente alla forzatura.
Visto che il comportamento è "undefined" potrebbe accadere anche qualcosa
di diverso. Se ci sono dei casi...
--
In silenzio anche un idiota sembra intelligente. Ma non c'è problema,
l'idiota vuol sempre dire la sua.
Angelo Paolitto
> Beh, i seguente codice:
> int *s;
> const int c = 2;
> s = (int *)&c;
> *s= 4;
> cout << c;
^^^^^^^^^^^^^^^^^^^^^^
Vai immediatamente dietro la lavagna e fai 5 minuti di vergogna!!!!
> sia il gcc (win32) che il vc lo compilano senza fiatare, ma in entrambi i
> casi la variabile const resiste stoicamente alla forzatura.
In realta' c non resiste alla modifica (basta dare un'occhiata al codice
assembler) e' il compilatore (C++ e non C) a fare in modo che venga
stampato il valore 2 (sostituendo 2 ogni volta che trova un'occorrenza di
c). g++ e VC++ si comportano alla stessa maniera perche' in C++ una const
e' realmente una costante.
Compilando il programma in C, sia gcc che VC++ stampano 4 (come ci si puo'
accorgere usando printf al posto di cout e dando l'estensione .c al nome
del file nel caso si usi VC++ :-))
Il C _*NON E'*_ un sotto insieme proprio del C++. In alcuni casi, con
istruzioni uguali, i due linguaggi si comportano in maniera diversa.
C:\>iao Angelo.
Marco Sarti
news:aogii0$nj3$1...@news.newsland.it:
> Vai immediatamente dietro la lavagna e fai 5 minuti di vergogna!!!!
Avevo la mia app di esempio cosě configurata, scusate. In effetti č stata
una mancanza determinante.
> In realta' c non resiste alla modifica (basta dare un'occhiata al
> codice assembler)
Pochi istanti dopo aver postato il msg mi sono messo di fronte al debugger
perchč non mi era chiaro. La locazione di memoria viene effettivamente
modificata. Evidentemente il C++ (scusate se ne parlo ancora per un
attimo...) nel caso di una variabile const non accede a quella locazione di
memoria.
> Il C _*NON E'*_ un sotto insieme proprio del C++. In alcuni casi, con
> istruzioni uguali, i due linguaggi si comportano in maniera diversa.
Yes, I know. Non so tutte le differenze, ogni tanto ne scopro una.
--
---
In silenzio anche un idiota sembra intelligente. Ma non c'č problema,