Gestione della memoria globale in C++ in stack o heap?

Question

Se dichiaro una struttura di dati globalmente in un'applicazione C++, consuma memoria di stack o memoria heap?

Per esempio

struct AAA 
{ 

.../.../. 
../../.. 
}arr[59652323]; 

Answer 1

Dal momento che non ero soddisfatto delle risposte, e spero che il karjatkar sameer vuole saperne di più di una semplice risposta si/no, qui si va.

Tipicamente un processo ha 5 diverse aree di memoria allocata

1. Codice - segmento di testo
2. inizializzato dati - segmento di dati
3. non inizializzata dati - bss segmento
4. Mucchio
5. Pila

Se si vuole veramente imparare ciò che viene salvato in cui quindi leggere e memorizzare questi:

COMPILER, ASSEMBLER, LINKER AND LOADER: A BRIEF STORY (vedere la tabella W.5)

Anatomy of a Program in Memory

alt text http://www.tenouk.com/ModuleW_files/ccompilerlinker006.png

Answer 2

Nessuno dei due. È una sezione .data.

Answer 3

memoria globale è pre-assegnati in un blocco di memoria fissa o sul mucchio, a seconda di come viene assegnato dalla vostra applicazione:

byte x[10]; // pre-allocated by the compiler in some fixed memory block 
byte *y 

main() 
{ 
    y = malloc(10); // allocated on the heap 
} 

EDIT:

La domanda è confuso: Se alloco una struttura di dati globalmente in un'applicazione C++, consuma memoria di stack o memoria heap?

"allocare"? Ciò potrebbe significare molte cose, compresa la chiamata a malloc(). Sarebbe stato diverso se la domanda fosse "se dichiaro e inizializzo una struttura di dati globalmente".

Molti anni fa, quando le CPU erano ancora utilizzando 64K segmenti, alcuni compilatori sono abbastanza intelligenti per allocare dinamicamente la memoria dall'heap invece di riservare un blocco nel segmento .data (a causa delle limitazioni nella architettura di memoria).

Credo di essere troppo vecchio ....

Answer 4

Se state esplicitamente assegnano la memoria voi stessi nuovi o malloc, allora saranno assegnati nel mucchio. Se il compilatore sta allocando la memoria, allora sarà allocata sullo stack.

Answer 5

Di solito non consuma nessuno dei due. Prova ad allocarli in un segmento di memoria che probabilmente rimarrà di dimensioni costanti per l'esecuzione del programma. Potrebbe essere bss, stack, heap o dati.

Answer 6

variabili globali vivono sullo heap. questi sono un caso speciale perché vivono per la vita del programma

Answer 7

L'oggetto globale stesso occuperà memoria che il runtime o il compilatore riserva per esso prima che venga eseguito main, questo non è un costo di runtime variabile quindi né stack né mucchio.

Se il ctor dell'oggetto assegna la memoria, si troverà nell'heap e qualsiasi allocazione successiva dell'oggetto sarà assegnata all'heap.

Dipende dalla natura esatta dell'oggetto globale, se è un puntatore o l'intero oggetto stesso che è globale.

Answer 8

Il problema qui è la domanda. Supponiamo che hai una piccola C (++ così, in cui gestire questo allo stesso modo) programma come questo:

/* my.c */ 

char * str = "Your dog has fleas."; /* 1 */ 
char * buf0 ;       /* 2 */ 

int main(){ 
    char * str2 = "Don't make fun of my dog." ; /* 3 */ 
    static char * str3 = str;   /* 4 */ 
    char * buf1 ;      /* 5 */ 
    buf0 = malloc(BUFSIZ);   /* 6 */ 
    buf1 = malloc(BUFSIZ);   /* 7 */ 

    return 0; 
} 

1. Questo non è né allocato sullo stack NOR sul mucchio. Invece, viene assegnato come dati statici e inserito nel proprio segmento di memoria sulla maggior parte delle macchine moderne. La stringa effettiva viene anche allocata come dati statici e inserita in un segmento di sola lettura in macchine pensanti.
2. è semplicemente un puntatore allocato statico; spazio per un indirizzo, in dati statici.
3. ha il puntatore allocato nello stack e verrà effettivamente deallocato quando restituisce main. La stringa, poiché è una costante, viene allocata nello spazio dati statico insieme alle altre stringhe.
4. viene effettivamente assegnato esattamente come in 2. La parola chiave static indica che non deve essere allocato nello stack.
5. ... ma buf1 è in pila e
6. ... lo spazio del buffer di mallocità è in pila.
7. E a proposito., I bambini non provano questo a casa. malloc ha un valore di ritorno di interesse; devi sempre controllare il valore restituito.

Ad esempio:

char * bfr; 
if((bfr = malloc(SIZE)) == NULL){ 
    /* malloc failed OMG */ 
    exit(-1); 
} 

Answer 9

Né dichiarare una struttura di dati globalmente in un C++ consuma memoria heap o stack. In realtà, le variabili globali sono tipicamente allocate in un segmento di dati le cui dimensioni rimangono invariate durante l'intero programma. Le pile e gli heap vengono in genere utilizzati per le variabili che vengono create e distrutte durante l'esecuzione del programma.