Newsgroup: it.comp.os.linux.development
Titolo: [C] Allocazione memoria array

Salve ragazzi, ho un dubbio, in C la memoria che viene riservata ad un
array, viene allocata dal compilatore, in fase di compilazione od
esecuzione(runtime)?
-- 
ICQ # 84624356
MSN 
lello...@katamail.com
Yahoo ilpuntatore

 esecuzione(runtime)?
int a[10] ;     // dinamica in esecuzione
static int b[10] ;     // statica area fissa nel eseguibile
HTH

 static int b[10] ;     // statica area fissa nel eseguibile
Entrambe le dichiarazioni allocano "staticamente" la memoria (cioè allocate
nella fase di compilazione/creazione eseguibile)
L'allocazione dinamica è quando viene allocata dinamicamente
a = malloc(10 * sizeof(int)); // linguaggio C
a = new int[10]; // linguaggio C++


Questo č proprio quello che volevo sapere, la memoria riservata all'array, 
viene allocata durante la fase di compilazione, o di esecuzione del 
programma? 

L'allocazione dinamica č quando viene allocata dinamicamente
credo non sia corretto:
1.  int a[10] ;     // dinamica in esecuzione sullo heap
2. static int b[10] ;     // statica area fissa nel eseguibile nell'area 
dati
3. malloc alloca dinamicamente in fase di esecuzione sullo heap
quindi che differenza c'č tra il caso 1 ed il 3 ?
che nel primo la dimensione č fissa, mentre nel secondo č variabile in fase 
di esecuzione.

 
dipenede da dove e' dichiarato a[]
Caso 1:
{
   int a[10] ;
   .
   .
   .
}
a e' allocato sullo stack e quindi dinamicamente.
Dopo } lo stack e' riposizionato e quindi a e' disallocato.
Caso 2:
int a[10] ;
{
   .
   .
   .
}
a e' allocato staticamente in fase di compliazione.
In ogni caso la parola chiave static rende la variabile statica, e 
quindi con allocazione in fase di compilazione.
Ad esempio:
{
   static int a[10] ;
   .
   .
   .
}
La variabile a e' statica, ovvero rientrando con il codice nello stesso 
punto si ritrovano i valori precedenti.
Dopo } la variabile non e' utilizzabile.
Ciao
Paolo

 variabile in fase di esecuzione nello HEAP.
 Per riferimento
http://www.numerix-dsp.com/appsnotes/cmemory.html
  a.. Heap Space - This is data space that is dynamically allocated, for
example using malloc () etc.
  b.. Global Variable Space - This is the memory space for global variables
that are statically allocated by the program. I.E. this memory space is
fixed in size at compile time.
  c.. Stack Space - This is a dynamic memory space that is used for function
parameters and variables that are local to a function.
Ciao

 3. malloc alloca dinamicamente in fase di esecuzione sullo heap
Rispondo alla domanda
la memoria riservata all'array,
viene allocata durante la fase di compilazione
SOLO se la variabile è dichiarata static.

> dipenede da dove e' dichiarato a[]
Vero, ma
Questo è un problema del compilatore che definisce per default come static 
le variabili esterne alle funzioni.
Per questo motivo è buona norma dichiarare SEMPRE le variabili static in 
modo esplicito rendendo il programma portabile su diversi compilatori.
Ciao

 modo esplicito rendendo il programma portabile su diversi compilatori.
Perche' esistono compilatori per cui in questo codice la variabile non 
e' static ? Pensavo che fosse uno standard C.
int a[10];
int foo () {
   .
   .
   return 0;
}
Ciao
Paolo

 int foo () {
Il termine "static" per le variabili globali ha un significato diverso.
Serve per renderle invisibili ad altri file oggetto ma le variabili globali
sono *sempre* allocate sullo heap.
Ciao,
-- 
Daniele Orlandi

 SOLO se la variabile č dichiarata static.
$ cat try.c
int aa[10];
int main() {
  int ab[10];
  int *ac = malloc( sizeof(int) * 10 );
  static int ad[10];
}
$ gcc try.c -o try
try.c: In function `main':
try.c:4: warning: initialization makes pointer from integer without a cast
$ nm try|egrep 'a(a|b|c|d)'
080495a0 B aa
08049560 b ad.0
In base a quanto sopra, aa e ad sono entrambe allocate in fase di compilazione,
aa come global e ad come local, mentre ab e ac sono variabile dinamiche,
allocate sullo stack (le memoria dell'array puntato da ac viene dall'HEAP).
Ciao,
-- 
        Roberto Divia`              Love at first sight is one of the greatest
Dep:PH Bat:53 Mailbox:C02110      labour-saving devices the world has ever seen
Route de Meyrin 385               ---------------------------------------------
Case Postale                                Phone:  
+41-22-767-4994
CH-1211 Geneve 23 CERN                      Fax:    
+41-22-767-9585
Switzerland                                 E-Mail: 
Robert...@cern.ch

 fase di esecuzione.
Che una viene allocata dinamicamente e AUTOMATICAMENTE sullo stack 
e l'altra MANUALMENTE e dinamicamente sulla heap.

 ma le variabili globali sono *sempre* allocate sullo heap.
La domanda originaria era se le variabili in C sono allocate durante la 
compilazione o run-time.
Secondo me le variabili globali sono allocate dal linker e quindi dire 
quando e' allocata la variabile:
   int a[10];
non e' possibile senza sapere dove e' stata definita:
- se e' una variabile globale e allocata dal linker
- se e' definita dopo una { e' allocata run-time sullo stack.
Ciao
Paolo

> SBAGLIATO: sullo stack (in dinamico, ma sullo stack)
Se leggevi il seguito del thread....

 modo esplicito rendendo il programma portabile su diversi compilatori.
Avevo letto (non chiedetemi dove che non mi ricordo) che in realtą il
compilatore se ne frega della direttiva static e alloca lo stesso
durante l'esecuzione. Questo ovviamente per motivi di ottimizzazione e
soltanto quando č possibile. Qualcuno di voi mi puņ confermare questa cosa?

 cosa?
No, č falso.