memory management global em C ++ em pilha ou heap?

Se eu declarar uma estrutura de dados globalmente em um aplicativo C ++, ela consome memory de pilha ou memory heap?

Por exemplo

struct AAA { .../.../. ../../.. }arr[59652323]; 

Desde que eu não estava satisfeito com as respostas, e espero que o mesmo karjatkar queira aprender mais do que apenas uma simples resposta sim / não, aqui vai você.

Normalmente, um processo tem 5 áreas diferentes de memory alocadas

  1. Código – segmento de texto
  2. Dados inicializados – segmento de dados
  3. Dados não inicializados – segmento bss
  4. Pilha
  5. Pilha

Se você realmente quer aprender o que é salvo, leia e marque:

COMPILADOR, MONTADOR, LINKER E CARREGADOR: UMA BREVE HISTÓRIA (veja a Tabela w.5)

Anatomia de um programa na memory

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

O problema aqui é a questão. Vamos supor que você tenha um pequeno programa C (++ também, eles lidam com isso da mesma forma) como este:

 /* 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. Isso não é alocado na pilha nem no heap. Em vez disso, ele é alocado como dados estáticos e colocado em seu próprio segmento de memory na maioria das máquinas modernas. A cadeia real também está sendo alocada como dados estáticos e colocada em um segmento somente leitura em máquinas que pensam corretamente.
  2. é simplesmente um ponteiro alocado estático; espaço para um endereço, em dados estáticos.
  3. tem o ponteiro alocado na pilha e será efetivamente desalocado quando o main retornar. A string, já que é uma constante, é alocada no espaço de dados estático junto com as outras strings.
  4. Na verdade, é alocado exatamente como em 2. A palavra-chave static informa que não deve ser alocada na pilha.
  5. … mas o buf1 está na pilha e
  6. … o espaço de buffer malloc está no heap.
  7. E, a propósito, as crianças não tentam isso em casa. malloc tem um valor de retorno de juros; você deve sempre verificar o valor de retorno.

Por exemplo:

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

Geralmente não consome nenhum dos dois. Ele tenta alocá-los em um segmento de memory que provavelmente permanecerá em tamanho constante para a execução do programa. Pode ser bss, pilha, heap ou dados.

Nem. É a seção .data.

A memory global é pré-alocada em um bloco de memory fixa ou no heap, dependendo de como ela é alocada por seu aplicativo:

 byte x[10]; // pre-allocated by the compiler in some fixed memory block byte *y main() { y = malloc(10); // allocated on the heap } 

EDITAR :

A questão é confusa: se eu alocar uma estrutura de dados globalmente em um aplicativo C ++, ela consome memory de pilha ou memory heap?

“distribuir”? Isso pode significar muitas coisas, incluindo chamar malloc (). Teria sido diferente se a pergunta fosse “se eu declarar e inicializar uma estrutura de dados globalmente”.

Muitos anos atrás, quando as CPUs ainda estavam usando segmentos de 64K, alguns compiladores eram inteligentes o suficiente para alocar dinamicamente a memory do heap em vez de reservar um bloco no segmento .data (devido a limitações na arquitetura da memory).

Eu acho que sou muito velho …

Nem declarar uma estrutura de dados globalmente em um C ++ consome memory heap ou pilha. Na verdade, as variables ​​globais são normalmente alocadas em um segmento de dados cujo tamanho permanece inalterado durante todo o programa. Pilhas e pilhas são normalmente usadas para variables ​​que são criadas e destruídas durante a execução do programa.

Espaço de memória do programa

O próprio object global ocupará a memory que o tempo de execução ou o compilador reserva para ele antes que o main seja executado; isso não é um custo de tempo de execução variável, portanto nem pilha nem heap.

Se o ctor do object alocar memory, ele estará no heap e quaisquer alocações subseqüentes pelo object serão alocações de heap.

Depende da natureza exata do object global, se é um ponteiro ou o object inteiro em si que é global.

variables ​​globais vivem no heap. estes são um caso especial porque eles vivem para a vida do programa

Se você estiver alocando explicitamente a memory por new ou malloc, ela será alocada no heap. Se o compilador estiver alocando a memory, ela será alocada na pilha.