O que e onde está a pilha e heap?

https://stackoverflow.com/questions/79923

09-06-2019
|

Pergunta

Linguagem de programação livros explicar que tipos de valores são criados no pilha, e tipos de referência são criados no pilha, sem explicar o que essas duas coisas são.Eu não li uma explicação clara sobre isso.Eu entendo o que uma pilha é.Mas,

Onde e o que são eles que (fisicamente em uma verdadeira memória do computador)?
Em que medida eles são controlados pelo sistema ou de tempo de execução idioma?
Qual é o seu âmbito de aplicação?
O que determina o tamanho de cada um deles?
O que faz um mais rápido?

Solução

A pilha é a memória posta de lado como um espaço scratch para um thread de execução.Quando uma função é chamada, um bloco é reservado no topo da pilha para variáveis locais e alguns de escrituração de dados.Quando a função retorna, o bloco torna-se não utilizados, e pode ser usado na próxima vez que uma função é chamada.A pilha é sempre reservado em um LIFO (last in first out) ordem;mais recentemente reservados bloco é sempre o próximo bloco a ser liberado.Isto torna muito simples para manter o controle da pilha;liberar um bloco da pilha é nada mais do que a adaptação de um ponteiro.

A pilha de memória reservada para alocação dinâmica.Ao contrário a pilha, não há imposto padrão para a alocação e desalocação de blocos da pilha;você pode alocar um bloco em qualquer altura e sem ele a qualquer momento.Isso torna muito mais complexo para manter o controle de quais partes da pilha são alocados ou livre em qualquer momento;há muitas personalizado pilha allocators disponíveis para ajustar o desempenho de heap para diferentes padrões de uso.

Cada thread recebe uma pilha, enquanto normalmente há apenas uma pilha para a aplicação (apesar de que não é incomum ter várias pilhas de tipos diferentes de alocação).

Para responder suas perguntas diretamente:

Em que medida eles são controlados pelo sistema ou de tempo de execução idioma?

O sistema operacional aloca a pilha para cada nível do sistema de thread quando a thread é criada.Normalmente, o sistema operacional é chamado pelo tempo de execução de idioma para alocar pilha para a aplicação.

Qual é o seu âmbito de aplicação?

A pilha está ligado a um segmento, então, quando o thread sai a pilha está recuperado.A pilha é normalmente atribuída na inicialização do aplicativo pelo tempo de execução, e é recuperada quando o aplicativo (tecnicamente processo) sai.

O que determina o tamanho de cada um deles?

O tamanho da pilha é definida quando um thread é criado.O tamanho da pilha é definido na inicialização do aplicativo, mas pode crescer à medida que o espaço é necessário (o alocador de pedidos de mais de memória do sistema operacional).

O que faz um mais rápido?

A pilha é mais rápido porque o padrão de acesso torna trivial para alocar e desalocar memória dele (um ponteiro inteiro é simplesmente incrementado ou decrementado), enquanto a pilha tem muito mais complexo contabilidade envolvidos em uma atribuição ou desalocação.Além disso, cada byte da pilha tende a ser reutilizado muito freqüentemente, o que significa que ele tende a ser mapeada para o cache do processador, tornando-se muito rápido.Outro impacto no desempenho para a pilha é que o heap, sendo principalmente um recurso global, normalmente tem de ser multi-threading seguro, i.é.cada alocação e desalocação precisa ser - normalmente sincronizados com "todos" os outros pilha de acessos no programa.

Uma demonstração clara:
_{Fonte da imagem: vikashazrati.wordpress.com}

Outras dicas

Pilha:

Armazenado na memória RAM do computador assim como a pilha.
Variáveis criadas na pilha vai sair do escopo e são automaticamente liberadas.
Muito mais rápido para alocar na comparação de variáveis na pilha.
Implementada a estrutura de dados da pilha.
Armazenamentos de dados locais, endereços de retorno, utilizado para a passagem de parâmetro.
Pode ter um estouro de pilha quando muito a pilha é utilizada (principalmente a partir de infinito ou muito profundo recursividade, muito grandes alocações).
Os dados criados na pilha pode ser usado sem ponteiros.
Você iria usar a pilha se você sabe exatamente quanto de dados você precisa alocar antes de compilar o tempo e ele não é muito grande.
Geralmente tem um tamanho máximo já determinado quando o programa é iniciado.

Pilha:

Armazenado na memória RAM do computador assim como a pilha.
Em C++, variáveis na pilha deve ser destruído manualmente e nunca cair fora do escopo.Os dados são liberados com delete, delete[], ou free.
Mais lento para alocar na comparação de variáveis na pilha.
Usado sob demanda para alocar um bloco de dados para uso pelo programa.
Pode ter a fragmentação quando há um monte de atribuições e deallocations.
Em C++ ou C, de dados criado na pilha será apontado pelos ponteiros e alocados com new ou malloc respectivamente.
Pode ter falhas de alocação de se demasiado grande de um buffer é solicitada a ser alocado.
Você iria usar a pilha se você não sabe exatamente quanto de dados você vai precisar em tempo de execução ou se você precisar alocar uma grande quantidade de dados.
Responsável por vazamentos de memória.

Exemplo:

int foo()
{
  char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).
  bool b = true; // Allocated on the stack.
  if(b)
  {
    //Create 500 bytes on the stack
    char buffer[500];

    //Create 500 bytes on the heap
    pBuffer = new char[500];

   }//<-- buffer is deallocated here, pBuffer is not
}//<--- oops there's a memory leak, I should have called delete[] pBuffer;

O ponto mais importante é que a pilha e heap são termos genéricos para as formas em que a memória pode ser alocada.Eles podem ser implementados em muitas maneiras diferentes, e os termos aplicam-se aos conceitos básicos.

Em uma pilha de itens, itens sentar um em cima do outro, na ordem em que eles foram colocados lá, e você só pode tirar a parte de cima (sem derrubar a coisa toda mais).

A simplicidade de uma pilha é que você não precisa manter uma tabela que contém um registro de cada seção de memória alocada;o estado somente as informações que você precisa é de um único ponteiro para o final da pilha.Para alocar e desalocar, você acabou de incremento e decremento único ponteiro.Nota:uma pilha pode às vezes ser implementadas para começar no topo de uma seção de memória e estender para baixo em vez de crescer para cima.
Em uma pilha, não há nenhuma ordem particular, para a maneira como os itens são colocados.Você pode acessar e remover itens em qualquer ordem, porque não há nenhuma clara 'top' do item.

Alocação de Heap requer a manutenção de um registro completo do que a memória é alocada e o que não é, bem como alguns sobrecarga de manutenção para reduzir a fragmentação, encontrar contíguos segmentos de memória grande o suficiente para caber o tamanho solicitado, e assim por diante.A memória pode ser liberada a qualquer hora, deixando livre o espaço.Às vezes, um alocador de memória irá executar tarefas de manutenção, como desfragmentação de memória ao mover alocada de memória, ou coleta de lixo - a identificação em tempo de execução quando a memória não está mais em termos de escopo e anular.

Estas imagens devem fazer um bom trabalho de descrever as duas formas de alocação e liberação de memória em uma pilha e heap.A Yum!

Em que medida eles são controlados pelo sistema ou de tempo de execução idioma?

Como mencionado, pilha e heap são termos gerais, e pode ser implementada de várias maneiras.Os programas de computador têm, tipicamente, uma pilha de chamada de uma pilha de chamada que armazena informações relevantes para a atual função como um ponteiro para qualquer função foi chamada, e quaisquer variáveis locais.Porque a chamada de funções outras funções e, em seguida, retornar, a pilha cresce e encolhe para reter informações a partir de funções mais para baixo na pilha de chamadas.Um programa realmente não tem tempo de execução de controle sobre ele;é determinado pela linguagem de programação, sistema operacional e até mesmo a arquitetura do sistema.

Uma pilha é um termo geral usado para qualquer memória alocada dinamicamente e de forma aleatória;i.e.fora de ordem.A memória é, normalmente, atribuído pelo sistema operacional, com a aplicação chamar funções da API para fazer essa alocação.Há um pouco de sobrecarga necessária no gerenciamento de memória alocada dinamicamente, o que geralmente é tratado pelo sistema operacional.
Qual é o seu âmbito de aplicação?

A pilha de chamadas é um nível tão baixo conceito que não se relacionam com o âmbito", no sentido de programação.Se você desmontar algum código que você vai ver em relação ponteiro do estilo de referências a partes da pilha, mas na medida em que um maior nível lingüístico, a linguagem impõe suas próprias regras de escopo.Um aspecto importante de uma pilha, no entanto, é que uma vez que uma função retorna, nada locais para que a função é imediatamente liberado da pilha.Que funciona da maneira que você esperaria que ele funcione dado como suas linguagens de programação de trabalho.Em uma pilha, é também difícil de definir.O escopo é tudo o que é exposto pelo sistema operacional, mas a sua linguagem de programação, provavelmente, adiciona suas regras sobre o que é um "escopo" é na sua aplicação.A arquitetura do processador e o sistema operacional usar endereçamento virtual, que o processador converte para endereços físicos e há falhas de página, etc.Eles acompanham as páginas que pertencem a quais aplicativos.Você nunca precisa se preocupar com isso, embora, porque você acabou de usar qualquer método que sua linguagem de programação usa para alocar e liberar memória, e verifique se há erros (se a alocação/liberação falhar por qualquer motivo).
O que determina o tamanho de cada um deles?

Mais uma vez, depende da linguagem, compilador, sistema operacional e arquitetura.Uma pilha geralmente é pré-atribuído, pois, por definição, deve ser contígua de memória (mais sobre isso no último parágrafo).O compilador de linguagem ou SO determinar o seu tamanho.Você não armazenar enormes quantidades de dados na pilha, de modo que ele vai ser grande o suficiente para que ele nunca deve ser totalmente utilizado, exceto em casos de indesejados recursão infinita (portanto, "estouro de pilha") ou incomuns de programação decisões.

Uma pilha é um termo geral para qualquer coisa que pode ser alocada dinamicamente.Dependendo de como você olha para ele, ele está constantemente mudando de tamanho.Nos processadores modernos sistemas operacionais e a maneira exata de como ele funciona é muito abstraídos de qualquer maneira, então você normalmente não precisa se preocupar muito sobre como ele funciona, no fundo, exceto que (em línguas onde ele permite que você) você não deve usar a memória que você não alocou ou ainda de memória que você tiver liberado.
O que faz um mais rápido?

A pilha é mais rápido porque toda a memória livre é sempre contíguos.Lista não precisa ser mantidos para todos os segmentos de memória livre, apenas um único ponteiro para o atual topo da pilha.Compiladores geralmente armazenar este ponteiro em um especial, rápido registar para este propósito.Além do mais, as operações subsequentes de uma pilha são geralmente concentradas dentro de muito próximas de áreas de memória, que, a um nível muito baixo é bom para otimização pelo processador on-die caches.

(Eu mudei esta resposta de outra pergunta que foi mais ou menos um dupe de um presente.)

A resposta para a sua pergunta é uma implementação específica e podem variar entre compiladores e arquiteturas de processador.No entanto, aqui está uma explicação simplificada.

Tanto a pilha e o heap são áreas de memória alocadas a partir do sistema operacional subjacente (muitas vezes de memória virtual que é mapeado para memória física sob demanda).
Em um ambiente multi-threaded cada thread tem seu próprio completamente independente pilha, mas eles irão compartilhar a pilha.Acesso simultâneo tem de ser controlado na pilha e não é possível na pilha.

A pilha

A pilha contém uma lista ligada de usados e blocos livres.Novas alocações de heap (por new ou malloc) são satisfeitas através da criação de um adequado bloco a partir de um dos blocos livres.Isso exige a atualização de lista de blocos da pilha.Este informações de meta sobre os blocos da pilha também é armazenado na pilha, muitas vezes, em uma pequena área na frente de cada bloco.
Como a pilha cresce de novos blocos são, muitas vezes, atribuídos a partir de endereços inferiores no sentido de uma maior endereços.Assim, você pode pensar que a pilha como uma pilha de blocos de memória que aumenta de tamanho à medida que a memória é alocada.Se o heap é muito pequeno para uma alocação do tamanho muitas vezes pode ser aumentada através da aquisição de mais memória do sistema operacional subjacente.
Alocando e desalocando muitos pequenos blocos podem deixar a pilha em um estado onde há um monte de pequenos blocos livres intercaladas entre os blocos usados.Uma solicitação para alocar um bloco grande pode falhar, pois nenhum dos blocos livres são grandes o suficiente para satisfazer a solicitação de alocação mesmo que o tamanho combinado dos blocos livres pode ser grande o suficiente.Isso é chamado de a fragmentação da heap.
Quando um bloco é adjacente a um bloco livre é desalocada o novo bloco livre pode ser mesclada com o adjacente bloco livre para criar uma maior bloco livre, efetivamente, reduzir a fragmentação da heap.

The heap

A pilha

A pilha muitas vezes trabalha em conjunto com um registro especial na CPU chamado de o ponteiro de pilha.Inicialmente, o ponteiro de pilha aponta para o topo da pilha (o endereço mais alto na pilha).
A CPU possui instruções especiais para empurrando valores para a pilha e popping - los de volta para a pilha.Cada push armazena o valor na localização atual do ponteiro de pilha e diminui o ponteiro de pilha.Um pop recupera o valor apontado pelo ponteiro de pilha e, em seguida, aumenta o ponteiro de pilha (não será confundido pelo fato de que adicionar um valor para a pilha diminui o ponteiro de pilha e a remoção um valor aumenta isso.Lembre-se de que a pilha cresce para baixo).Os valores armazenados e recuperados são os valores dos registradores da CPU.
Quando uma função é chamada a CPU usa instruções especiais que empurrar o atual ponteiro de instrução, i.é.o endereço do código em execução na pilha.A CPU, em seguida, salta para a função de definir o ponteiro de instrução para o endereço da função chamada.Mais tarde, quando a função retorna, o antigo ponteiro de instrução é removido da pilha e a execução é retomada no código logo após a chamada para a função.
Quando uma função é inserido, o ponteiro da pilha é reduzido para alocar mais espaço na pilha para o local (automático) variáveis.Se a função tem um local de 32 bits variável de quatro bytes são deixadas de lado na pilha.Quando a função retorna, o ponteiro da pilha é movido de volta para liberar a área alocada.
Se uma função tenha parâmetros, estes são enviados para a pilha antes da chamada à função.O código da função é então capaz de navegar até a pilha do ponteiro de pilha atual para localizar esses valores.
Aninhamento de chamadas de função funciona como um encanto.A cada nova chamada será alocar os parâmetros da função, o endereço de retorno e de espaço para variáveis locais e estes registros de ativação podem ser empilhados para chamadas aninhadas e vai relaxar no caminho correto quando as funções de retorno.
Como a pilha está limitado a um bloco de memória, você pode causar um estouro de pilha chamando muitas funções aninhadas e/ou da alocação de muito espaço para as variáveis locais.Muitas vezes, a área de memória usada para a pilha está configurada de tal forma que a escrita abaixo da parte inferior (o endereço mais baixo) da pilha irá desencadear uma armadilha ou de exceção na CPU.Esta condição excepcional, em seguida, pode ser pego pelo tempo de execução e convertidos em algum tipo de exceção de estouro de pilha.

The stack

Pode uma função a ser alocado no heap em vez de uma pilha?

Não, a ativação de registros para funções (por exemplo,local ou automática de variáveis) são alocados na pilha, que é utilizado não só para armazenar estas variáveis, mas também para manter o controle de chamadas de função aninhada.

Como a pilha é gerenciado é, realmente, até o ambiente de tempo de execução.C usa malloc e C++ usa new, mas muitas outras línguas têm coleta de lixo.

No entanto, a pilha é um mais baixo nível de funcionalidade intimamente ligada à arquitetura do processador.Crescendo a pilha quando não há espaço suficiente, não é muito difícil, já que pode ser implementado na chamada de biblioteca que lida com a pilha.Entretanto, o crescimento da pilha é muitas vezes impossível, como o estouro de pilha só é descoberto quando é tarde demais;e encerrar a thread de execução é a única opção viável.

No seguinte código C#

public void Method1()
{
    int i = 4;
    int y = 2;
    class1 cls1 = new class1();
}

Veja como a memória é gerenciada

Picture of variables on the stack

Local Variables que só precisa durar tanto tempo como a invocação de função ir na pilha.A pilha é utilizada para as variáveis cujo tempo de vida nós realmente não sabemos frente, mas nós esperamos que eles durar um tempo.Na maioria dos idiomas, é fundamental que nós sabemos em tempo de compilação como o tamanho de uma variável é se o que se pretende armazená-lo na pilha.

Objetos (que variam em tamanho, como podemos atualizá-los) vá em pilha, porque nós não sabemos no momento da criação quanto tempo eles vão durar.Em muitos idiomas, o heap é coletado pelo coletor de lixo para encontrar objetos (tais como o cls1 objeto) que não tem mais referências.

Em Java, a maioria dos objetos ir diretamente para a pilha.Em linguagens como C / C++, estruturas e classes pode, muitas vezes, permanecem na pilha quando você não está lidando com ponteiros.

Mais informações podem ser encontradas aqui:

A diferença entre a pilha e a pilha de alocação de memória " timmurphy.org

e aqui:

A criação de Objetos na Pilha e Heap

Este artigo é a fonte da imagem acima: Seis importante .NET conceitos:Pilha, heap, tipos de valor, tipos de referência, boxing e unboxing - CodeProject

mas esteja ciente de que podem conter algumas imprecisões.

A Pilha Quando você chamar uma função os argumentos da função além de algumas outras sobrecarga é colocada na pilha.Algumas informações (tais como onde ir no retorno) também é armazenado lá.Quando você declara uma variável dentro de sua função, essa variável também está alocada na pilha.

Anular a pilha é muito simples, porque você sempre desalocar na ordem inversa em que você alocar.Pilha de coisas é acrescentado, como você entrar em funções, a de dados correspondente é removida como sair deles.Isso significa que você tende a ficar dentro de uma pequena região da pilha, a menos que você chamar muitas funções que chamam muitas outras funções (ou criar uma solução recursiva).

A Pilha A pilha é um nome genérico para onde você colocar os dados que você criar na mosca.Se você não sabe quantas naves seu programa vai criar, é provável que você use o novo (ou malloc ou equivalente) operador para criar cada nave espacial.Esta atribuição está indo para ficar por um tempo, por isso é provável que vamos libertar as coisas em uma ordem diferente do que criou.

Assim, a pilha é muito mais complexa, porque não acabar sendo regiões de memória que não são utilizadas intercalados com blocos de memória fica fragmentado.Encontrar a memória livre do tamanho que você precisa é de um difícil problema.É por isso que a pilha deve ser evitado (o que é ainda frequentemente utilizado).

Implementação Implementação de pilha e heap é, geralmente, para baixo, para o tempo de execução / OS.Muitas vezes, jogos e outros aplicativos que estão com desempenho crítico de criar suas próprias soluções de memória que pegar um pedaço grande de memória do heap e, em seguida, prato-lo internamente para evitar depender do sistema operacional para a memória.

Esta é, na prática, só se o uso de memória é bastante diferente da norma - eu.e para jogos onde você carregar um nível em uma enorme operação e pode chuck todo o lote de distância, em outra grande operação.

Localização física na memória Isso é menos relevante do que você acha que por causa de uma tecnologia chamada Memória Virtual o que torna o seu programa de pensar que você tem acesso a um determinado endereço onde o físico de dados é em outro lugar (até mesmo em seu disco rígido!).Os endereços que você obter para a pilha em ordem crescente como a sua chamada árvore fica mais profundo.Os endereços para o heap são não-previsível (que eu.e implimentation específico) e, francamente, não é importante.

Para esclarecer, esta resposta tem informações incorrectas (thomas fixo a sua resposta depois de comentários, que legal :) ).Outras respostas apenas evite explicar o que a alocação estática significa.Por isso vou explicar os três principais formas de alocação e como eles se relacionam com a pilha, pilha, e o segmento de dados abaixo.Eu também irá mostrar alguns exemplos em C/C++ e Python para ajudar as pessoas a entender.

"Estático" (AKA alocado estaticamente) variáveis não são alocados na pilha.Não assumimos assim, muitas pessoas o fazem apenas porque "estático" soa muito como "pilha".Eles realmente existem nem a pilha nem a pilha.O são parte do que é chamado de segmento de dados.

No entanto, é recomendável levar em conta "âmbito de aplicação"e "tempo de vida"em vez de "pilha" e "pilha".

O escopo refere-se a quais partes do código podem aceder a uma variável.Geralmente pensamos âmbito local (só pode ser acessado por função atual) versus escopo global (pode ser acessado de qualquer lugar) apesar de escopo pode obter muito mais complexo.

Tempo de vida refere-se a quando uma variável é alocada e desalocada durante a execução do programa.Geralmente pensamos alocação estática (variável persistirá por toda a duração do programa, tornando-o útil para armazenar a mesma informação através de várias chamadas de função) versus atribuição automática (variável só persiste durante uma única chamada para uma função, tornando-o útil para o armazenamento de informações que é usado apenas durante a sua função e pode ser descartada uma vez que você está feito) versus alocação dinâmica (variáveis, cuja duração é definida em tempo de execução, em vez de tempo de compilação como estático ou automático).

Embora a maioria dos compiladores e interpretadores de implementar esse comportamento de forma semelhante em termos de uso de pilhas, pilhas, etc., um compilador pode, por vezes, quebrar essas convenções se ele quer, enquanto o comportamento é correto.Por exemplo, devido à otimização de uma variável local só pode existir em um registrador ou ser totalmente removido, mesmo que a maioria de variáveis locais existem na pilha.Como tem sido apontado em alguns comentários, você é livre para implementar um compilador, mesmo que não use uma pilha ou uma pilha, mas em vez disso, alguns outros mecanismos de armazenamento (raramente é feito, desde pilhas e pilhas são ótimos para isso).

Eu vou fornecer algumas simples anotado código C para ilustrar tudo isso.A melhor maneira de aprender é executar um programa em um depurador e observar o comportamento.Se você preferir ler python, vá para o final da resposta :)

// Statically allocated in the data segment when the program/DLL is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in the code
int someGlobalVariable;

// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in this particular code file
static int someStaticVariable;

// "someArgument" is allocated on the stack each time MyFunction is called
// "someArgument" is deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
void MyFunction(int someArgument) {

    // Statically allocated in the data segment when the program is first loaded
    // Deallocated when the program/DLL exits
    // scope - can be accessed only within MyFunction()
    static int someLocalStaticVariable;

    // Allocated on the stack each time MyFunction is called
    // Deallocated when MyFunction returns
    // scope - can be accessed only within MyFunction()
    int someLocalVariable;

    // A *pointer* is allocated on the stack each time MyFunction is called
    // This pointer is deallocated when MyFunction returns
    // scope - the pointer can be accessed only within MyFunction()
    int* someDynamicVariable;

    // This line causes space for an integer to be allocated in the heap
    // when this line is executed. Note this is not at the beginning of
    // the call to MyFunction(), like the automatic variables
    // scope - only code within MyFunction() can access this space
    // *through this particular variable*.
    // However, if you pass the address somewhere else, that code
    // can access it too
    someDynamicVariable = new int;


    // This line deallocates the space for the integer in the heap.
    // If we did not write it, the memory would be "leaked".
    // Note a fundamental difference between the stack and heap
    // the heap must be managed. The stack is managed for us.
    delete someDynamicVariable;

    // In other cases, instead of deallocating this heap space you
    // might store the address somewhere more permanent to use later.
    // Some languages even take care of deallocation for you... but
    // always it needs to be taken care of at runtime by some mechanism.

    // When the function returns, someArgument, someLocalVariable
    // and the pointer someDynamicVariable are deallocated.
    // The space pointed to by someDynamicVariable was already
    // deallocated prior to returning.
    return;
}

// Note that someGlobalVariable, someStaticVariable and
// someLocalStaticVariable continue to exist, and are not
// deallocated until the program exits.

Particularmente tocante exemplo de por que é importante distinguir entre o tempo de vida e o alcance é de que uma variável pode ter escopo local, mas estático vida - por exemplo, "someLocalStaticVariable" no código de exemplo acima.Tais variáveis podem tornar a nossa comum, mas informal de nomeação de hábitos muito confuso.Por exemplo, quando dizemos "local"costumamos dizer "escopo local automaticamente alocados variável"e quando dizemos global, referimo-nos normalmente "escopo global alocado estaticamente variável".Infelizmente, quando se trata de coisas como "escopo do arquivo estaticamente atribuídos a variáveis"muitas pessoas só dizer..."hein???".

Algumas das sintaxe escolhas em C/C++ agravar este problema - por exemplo, muitas pessoas pensam variáveis globais não são "estáticos", porque a sintaxe mostrada abaixo.

int var1; // Has global scope and static allocation
static int var2; // Has file scope and static allocation

int main() {return 0;}

Observe que colocar a palavra-chave "static" na declaração acima não impede var2 de ter escopo global.No entanto, o global var1 tem a atribuição estática.Isto não é intuitivo!Por esta razão, eu tento nunca use a palavra "static" ao descrever o escopo, e em vez de dizer algo como "arquivo" ou "arquivo" limitada escopo.No entanto, muitas pessoas utilizam a expressão "estático" ou "escopo estático" para descrever uma variável que só pode ser acessado a partir de um arquivo de código.No contexto da vida, "estática" sempre significa que a variável é alocada no início do programa e desalocada quando sai do programa.

Algumas pessoas pensam desses conceitos, como C/C++ específico.Eles não são.Por exemplo, o Python exemplo abaixo ilustra os três tipos de alocação (há algumas diferenças sutis possível em linguagens interpretadas que eu não vou entrar aqui).

from datetime import datetime

class Animal:
    _FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated

    def PetAnimal(self):
        curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion
        print("Thank you for petting me. But it's " + str(curTime) + ", you should feed me. My favorite food is " + self._FavoriteFood)

class Cat(Animal):
    _FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's

class Dog(Animal):
    _FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!


if __name__ == "__main__":
    whiskers = Cat() # Dynamically allocated
    fido = Dog() # Dynamically allocated
    rinTinTin = Dog() # Dynamically allocated

    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

    Dog._FavoriteFood = 'milkbones'
    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

# Output is:
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones
# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones

Outros responderam a ampla traços muito bem, então eu vou jogar alguns detalhes.

Pilha e a pilha não necessita de ser singular.Uma situação comum em que você tem mais do que uma pilha é se você tiver mais de uma thread em um processo.Neste caso, cada segmento tem sua própria pilha.Você também pode ter mais de uma pilha, por exemplo, alguns DLL configurações podem resultar em diferentes DLLs atribuição de diferentes pilhas, que é geralmente uma má idéia para liberar a memória alocada por uma biblioteca diferente.
Em C você pode obter o benefício de comprimento variável de alocação por meio do uso de alloca, que aloca na pilha, como oposição a alocação, que atribui a pilha.Essa memória não vai sobreviver a instrução de retorno, mas é útil para um buffer rascunho.
Fazendo uma enorme buffer temporário no Windows que você não usa muito não é livre.Isso ocorre porque o compilador irá gerar uma pilha de sonda ciclo que é chamado cada vez que sua função é introduzido para certificar-se de que a pilha existe (porque o Windows usa uma única página de guarda no final da sua pilha para detectar quando ele precisa para aumentar a pilha.Se você acessar a memória mais do que uma página fora da extremidade da pilha, você irá falhar).Exemplo:

void myfunction()
{
   char big[10000000];
   // Do something that only uses for first 1K of big 99% of the time.
}

Outros têm diretamente respondeu a sua pergunta, mas ao tentar compreender a pilha e o heap, eu acho que é útil considerar o layout de memória de um tradicional do UNIX processo (sem linhas e mmap()baseado no allocators).O Gerenciamento De Memória Glossário página da web tem um diagrama deste layout de memória.

Pilha e heap são tradicionalmente localizados em extremidades opostas do processo do espaço de endereço virtual.A pilha cresce automaticamente quando acessado, até um tamanho definido pelo kernel (que pode ser ajustado com setrlimit(RLIMIT_STACK, ...)).A pilha cresce quando o alocador de memória invoca o brk() ou sbrk() chamada de sistema, mapeamento mais páginas de memória física no processo do espaço de endereço virtual.

Em sistemas sem memória virtual, como alguns sistemas embarcados, o mesmo layout básico, muitas vezes, aplica-se, excepto a pilha e heap são de tamanho fixo.No entanto, em outros sistemas incorporados (como as baseadas em microcontroladores Microchip PIC), o programa de pilha é um bloco de memória que não é endereçável por instruções de movimento de dados, e só pode ser modificado ou lido indiretamente, através de instruções de fluxo de programa (chamada de retorno, etc.).Outras arquiteturas, tais como processadores Intel Itanium, ter várias pilhas.Neste sentido, a pilha é um elemento da arquitetura de CPU.

A pilha é uma parte da memória que pode ser manipulado através de várias chaves de linguagem de montagem instruções, tais como 'pop' (remover e retornar um valor da pilha) e "push" (empurrar um valor para a pilha), mas também de chamada (chamada a uma sub - rotina -, este empurra o endereço de retorno na pilha) e retorno (retorno de uma sub - rotina- esta aparece o endereço fora da pilha e salta para ele).É a região de memória abaixo o registo de ponteiro de pilha, que pode ser definido como necessário.A pilha também é usado para passar argumentos para o sub-rotinas, e também para preservar os valores nos registradores antes de chamar sub-rotinas.

A pilha é uma parte da memória que é dado a uma aplicação pelo sistema operacional, normalmente através de uma syscall como malloc.Nos sistemas Operacionais modernos, esta memória é um conjunto de páginas que só o processo de chamada tem acesso.

O tamanho da pilha é determinado em tempo de execução, e, geralmente, não crescer depois que o programa for iniciado.Em um programa C, a pilha deve ser grande o suficiente para armazenar cada variável declarada dentro de cada função.A pilha vai crescer dinamicamente conforme necessário, mas o sistema operacional é, em última análise, de fazer a chamada (que, muitas vezes, aumentar a pilha por mais do que o valor pedido por malloc, para que pelo menos alguns futuro mallocs não precisa voltar para o kernel para obter mais memória.Este comportamento é, muitas vezes, personalizável)

Porque você já alocado na pilha antes de lançar o programa, você nunca precisa malloc antes de você pode usar a pilha, de modo que uma ligeira vantagem lá.Na prática, é muito difícil prever o que vai ser rápido, e o que vai ser lenta nos sistemas operacionais modernos, que têm memória virtual subsistemas, porque a forma como as páginas são implementados e onde eles estão armazenados é um detalhe de implementação.

Eu acho que muitas outras pessoas têm dado, principalmente, respostas corretas nesta questão.

Um detalhe que foi perdido, no entanto, é que a "pilha" deveria, provavelmente, ser chamado de o "free store".A razão para esta distinção é de que o original free store foi implementado com uma estrutura de dados conhecida como "heap binomial." Por essa razão, a alocação a partir do início de implementações de malloc () livre() foi de alocação a partir de uma pilha.No entanto, nos dias modernos, a maioria das lojas são implementadas com muito elaborado estruturas de dados que não são heaps binomiais.

O que é uma pilha?

Uma pilha é uma pilha de objetos, normalmente uma que está bem organizado.

Pilhas em arquiteturas são regiões de memória onde os dados são adicionados ou removidos em uma last-in-first-out maneira.
Em uma aplicação multi-tarefa, cada segmento tem sua própria pilha.

O que é uma pilha?

Uma pilha é um jeito coleção de coisas empilhadas desordenadamente.

Em arquitecturas de computadores a pilha é uma área de memória alocada dinamicamente é gerenciado automaticamente pelo sistema operacional ou o gerenciador de memória da biblioteca.
Memória no heap é atribuída, desalocada, e redimensionada, regularmente, durante a execução do programa, e isso pode levar a um problema chamado de fragmentação.
A fragmentação ocorre quando objetos de memória são alocados com pequenos espaços entre os que são demasiado pequena para conter adicionais de memória de objetos.
O resultado é uma porcentagem do espaço de pilha que não é utilizável para mais alocações de memória.

Os dois juntos

Em uma aplicação multi-tarefa, cada segmento tem sua própria pilha.Mas, todas as diferentes threads irão compartilhar a pilha.
Porque as diferentes threads compartilham a pilha em uma aplicação multi-tarefa, isso também significa que tem de ser alguma coordenação entre os segmentos, de modo que eles não tentam acessar e manipular a mesma peça(s) de memória na pilha ao mesmo tempo.

O que é mais rápido – a pilha ou a pilha?E por quê?

A pilha é muito mais rápido do que a pilha.
Isso é devido a maneira como a memória é alocada na pilha.
A alocação de memória na pilha é tão simples como mover o ponteiro de pilha para cima.

Para as pessoas novas para a programação, é provavelmente uma boa idéia para usar a pilha, já que é mais fácil.
Porque a pilha é pequeno, você iria querer usá-lo quando você sabe exatamente o quanto de memória será necessário para os seus dados, ou se você souber o seu tamanho é muito pequeno.
É melhor usar a pilha quando você sabe que você vai precisar de muita memória para os seus dados, ou você simplesmente não tem certeza de quanto de memória você vai precisar (como com uma matriz dinâmica).

Modelo De Memória Java

A pilha é a área de memória onde as variáveis locais (incluindo os parâmetros do método) são armazenados.Quando se trata de variáveis de objeto, estas são apenas referências (ponteiros) para o real objetos no heap.
Toda vez que um objeto é instanciado, um bloco de heap de memória é reservado para armazenar os dados (estado) do objeto.Como os objetos podem conter outros objetos, alguns dos dados pode, na verdade, manter as referências a esses objetos aninhados.

Você pode fazer algumas coisas interessantes com a pilha.Por exemplo, você têm funções alloca (supondo que você pode obter passado a abundância de avisos relativos a seu uso), que é uma forma de malloc que usa especificamente a pilha, não o heap de memória.

O que disse, baseado em pilha de erros de memória são alguns dos piores que eu já experimentei.Se você usar o heap de memória, e você ultrapassar os limites do seu bloco alocado, você tem uma boa chance de disparar uma falha de segmento.(Não 100%:o bloco pode ser, aliás, contígua com a outra que você tiver atribuído anteriormente.) Mas desde que as variáveis criadas na pilha sempre são contíguos com os outros, a escrita fora dos limites pode alterar o valor de outra variável.Aprendi que sempre que eu sinto que o meu programa parou de obedecer as leis da lógica, é, provavelmente, estouro de buffer.

Simplesmente, a pilha é onde as variáveis locais são criadas.Além disso, a cada vez que você chamar uma sub-rotina, o contador de programa (ponteiro para a próxima instrução de máquina) e quaisquer registos importantes e, por vezes, os parâmetros empurrado para a pilha.Em seguida, quaisquer variáveis locais dentro da sub-rotina são colocados na pilha (e utilizado a partir de lá).Quando a sub-rotina termina, isso tudo fica apareceu de volta na pilha.O PC e registar dados e colocar de volta onde estava como ele é estourado, então o programa pode ir em seus alegres forma.

A pilha é a área de memória dinâmica alocações de memória são feitas de (explícito "novo" ou "atribuir" chamadas).É uma estrutura de dados especial que pode manter o controle de blocos de memória de tamanhos variados e o seu status de alocação.

No "clássico" sistemas de RAM foi disposta de tal forma que o ponteiro da pilha começou no fundo da memória, o ponteiro de pilha começou no topo, e eles cresceram um para com o outro.Se eles se sobrepõem, você está fora da RAM.Que não funciona com o moderno multi-threaded Sos embora.Cada segmento tem sua própria pilha, e aqueles que podem obter criada dynamicly.

A Partir De WikiAnwser.

Pilha

Quando uma função ou um método chama outra função que transforma em chama outra função, etc., a execução de todas as funções permanece suspenso até que o último função retorna o seu valor.

Esta cadeia de suspensão de chamadas de função é a pilha, uma vez que os elementos na pilha (chamadas de função) dependem uns dos outros.

A pilha é importante considerar no tratamento de exceção e execuções de thread.

Pilha

A pilha é simplesmente a memória utilizada pelos programas para armazenar variáveis.Elemento da pilha (variáveis) sem dependências uns com os outros e sempre podem ser acessados aleatoriamente a qualquer momento.

Pilha

Acesso muito rápido
Não tem explicitamente de-alocar variáveis
O espaço é gerido de forma eficiente por CPU, memória não vai ficar fragmentados
Somente as variáveis locais
Limite de tamanho de pilha (OS dependentes)
As variáveis não podem ser redimensionadas

Pilha

As variáveis podem ser acessados globalmente
Não há limite no tamanho da memória
(Relativamente) mais lento o acesso
Nenhuma garantia de uma utilização eficiente do espaço, a memória pode se tornar fragmentados ao longo do tempo como blocos de memória são alocados, em seguida, liberado
Você deve gerenciar a memória (você está no comando de alocação e liberação de variáveis)
As variáveis podem ser redimensionada usando realloc()

OK, de forma simples e em palavras curtas, elas significam ordenar e não ordenado...!

Pilha:Na pilha de itens, as coisas ficam no topo de cada outra, significa que vai ser mais rápido e mais eficiente para ser processado!...

Por isso, sempre há um índice para apontar o item específico, também o processamento vai ser mais rápido, não há relação entre os itens bem!...

Pilha:Nenhuma ordem, o processamento vai ser mais lento e valores estão bagunçados junto com nenhuma ordem específica ou índice de...não são aleatórios e não há nenhuma relação entre eles...assim, a execução e o tempo de uso pode ser variar...

Eu também criar a imagem abaixo para mostrar como eles podem olhar como:

Em Breve

Uma pilha é usada para estática, alocação de memória e uma pilha de alocação dinâmica de memória, armazenados na memória RAM do computador.

Em Detalhe

A Pilha

A pilha é uma "LIFO" (último a entrar, primeiro a sair), estrutura de dados, que é gerenciado e otimizado pela CPU muito de perto.Cada vez que uma função declara uma variável nova, ele é "empurrado" para a pilha.Em seguida, cada vez que uma função é encerrado, todas as variáveis empurrado para a pilha por essa função, são liberados (isto é, eles são excluídos).Uma vez que uma variável de pilha é liberado, a que região da memória torna-se disponível para outros pilha de variáveis.

A vantagem de usar a pilha para armazenar variáveis, é que a memória é gerenciada por você.Você não tem que alocar memória com a mão ou livre-lo uma vez que você não precisa de mais nada.O que é mais, porque a CPU organiza a memória de pilha, de modo eficiente, a leitura e a escrita para as variáveis de pilha é muito rápido.

Mais pode ser encontrado aqui.

A Pilha

A pilha é uma região da memória do seu computador que não é gerenciado automaticamente para você, e não é tão bem gerida pela CPU.Ele é uma maneira mais livre-flutuante região de memória (e maior).Para alocar memória no heap, você deve usar malloc() e calloc(), que estão incorporados no C as funções.Uma vez que você tenha memória alocada no heap, você é responsável pelo uso livre() para desalocar memória, uma vez que você não precisa de mais nada.

Se você não conseguir fazer isso, o programa irá têm o que é conhecido como uma fuga de memória.Que é, de memória no heap ainda será definido de lado (e não estará disponível para outros processos).Como veremos na secção a depuração, há uma ferramenta chamada Valgrind que pode ajudar a detectar fugas de memória.

Ao contrário a pilha, a pilha não tem restrições de tamanho variável tamanho (para além das óbvias limitações físicas do seu computador).Heap de memória é um pouco mais lento para ser lidos e escritos, porque tem um para usar ponteiros para acesso de memória no heap.Vamos falar sobre ponteiros em breve.

Ao contrário a pilha de variáveis criadas na pilha de são acessíveis por qualquer função, em qualquer lugar no seu programa.Pilha variáveis são essencialmente de âmbito global.

Mais pode ser encontrado aqui.

Variáveis alocadas na pilha são armazenados diretamente para a memória e o acesso a essa memória é muito rápido, e a sua alocação é tratada quando o programa é compilado.Quando uma função ou um método chama outra função que transforma em chama outra função, etc., a execução de todas as funções permanece suspenso até que o último função retorna o seu valor.A pilha é sempre reservado em um LIFO fim, mais recentemente reservados bloco é sempre o próximo bloco a ser liberado.Isto torna muito simples para manter o controle da pilha, liberar um bloco da pilha é nada mais do que a adaptação de um ponteiro.

Variáveis alocadas na pilha de ter sua memória alocada em tempo de execução e acessar essa memória é um pouco mais lenta, mas o tamanho de heap é limitado apenas pelo tamanho da memória virtual.Elementos da pilha não tem nenhuma dependência com o outro e sempre podem ser acessados aleatoriamente a qualquer momento.Você pode alocar um bloco em qualquer altura e sem ele a qualquer momento.Isso torna muito mais complexo para manter o controle de quais partes da pilha são atribuídos, ou gratuitamente, a qualquer momento.

Você pode usar a pilha se você sabe exatamente quanto de dados você precisa alocar antes de tempo de compilação, e ele não é muito grande.Você pode usar a pilha se você não sabe exatamente quanto de dados você vai precisar em tempo de execução ou se você precisar alocar uma grande quantidade de dados.

Em uma multi-threaded situação de cada thread tem seu próprio completamente independente de pilha, mas eles irão compartilhar a pilha.A pilha de thread específico e o heap é específico do aplicativo.A pilha é importante considerar no tratamento de exceção e execuções de thread.

Cada thread recebe uma pilha, enquanto normalmente há apenas uma pilha para a aplicação (apesar de que não é incomum ter várias pilhas de tipos diferentes de alocação).

Em tempo de execução, se a aplicação necessitar de mais de pilha, ele pode alocar a memória da memória livre e se a pilha precisa de memória, ele pode alocar memória de liberar memória alocada memória para o aplicativo.

Ainda para mais detalhes aqui e aqui.

Agora vêm a sua pergunta respostas.

Em que medida eles são controlados pelo sistema ou de tempo de execução idioma?

Mais pode ser encontrado aqui.

Qual é o seu âmbito de aplicação?

Já no topo.

"Você pode usar a pilha se você sabe exatamente quanto de dados você precisa alocar antes de tempo de compilação, e ele não é muito grande.Você pode usar a pilha se você não sabe exatamente quanto de dados você vai precisar em tempo de execução ou se você precisar alocar uma grande quantidade de dados."

Mais pode ser encontrado em aqui.

O que determina o tamanho de cada um deles?

O tamanho da pilha é definida por OS quando um thread é criado.O tamanho da pilha é definido na inicialização do aplicativo, mas pode crescer à medida que o espaço é necessário (o alocador de pedidos de mais de memória do sistema operacional).

O que faz um mais rápido?

Alocação de pilha é muito mais rápido, pois tudo o que ele realmente faz é mover o ponteiro de pilha.Usando pools de memória, você pode obter desempenho comparável de alocação de heap, mas que vem com uma ligeira maior complexidade e suas próprias dores de cabeça.

Além disso, a pilha de vs.heap não é apenas uma consideração de desempenho;ele também diz muito sobre a expectativa de vida dos objetos.

Os detalhes podem ser encontrados a partir de aqui.

Na década de 1980, UNIX propagadas como coelhos com grandes empresas de rolamento próprias.A Exxon teve um, como fizeram dezenas de nomes de marca que se perderam para a história.Como a memória foi colocado para fora foi, a critério dos muitos implementadores.

Um típico programa em C foi estabelecida a televisão na memória com uma oportunidade para aumentar alterando a brk() valor.Normalmente, a PILHA foi um pouco abaixo deste valor brk e o aumento brk aumentou a quantidade disponível de pilha.

A única PILHA era tipicamente uma área abaixo de PILHA, que foi um trato de memória contém nada de valor até o início da próxima fixo bloco de memória.Este bloco seguinte foi muitas vezes de CÓDIGO que podem ser substituídos por dados da pilha em um dos famosos hacks de sua época.

Um típico bloco de memória foi BSS (um bloco de valores de zero) o que foi, acidentalmente, não zerado de um fabricante a oferecer.Outra foi a de DADOS contendo inicializado valores, incluindo seqüências de caracteres e números.Um terceiro foi de CÓDIGO contendo CRT (de tempo de execução C), de principal, funções e bibliotecas.

O advento da memória virtual no UNIX alterações de muitas das restrições.Não há nenhuma razão objetiva por esses blocos precisa ser contíguo, ou de tamanho fixo, ou de ordenar, de maneira particular agora.É claro que, antes do UNIX foi Multics, que não sofrem essas restrições.Aqui está um diagrama esquemático mostrando um dos memória de layouts do que era.

A typical 1980s style UNIX C program memory layout

pilha, pilha e dados de cada processo em memória virtual:

Um par de centavos:Eu acho que vai ser bom para desenhar de memória gráfica e mais simples:

Setas - show onde crescer pilha e heap, o processo de tamanho de pilha tem limite, definido no sistema operacional, a pilha de thread limites de tamanho de parâmetros no segmento de criar API normalmente.Pilha, normalmente, a limitação pelo processo de máximo tamanho de memória virtual, para a versão de 32 bits 2 a 4 GB, por exemplo.

Tão simples maneira:pilha de processo é geral para o processo e todas as threads dentro, usando para alocação de memória em caso comum com algo como malloc().

Pilha é rápida memória para armazenar em caso comum de retorno de função, ponteiros e variáveis, tratados como parâmetros na chamada de função, local as variáveis da função.

Uma vez que algumas respostas foram picuinhas, eu vou contribuir com a minha ácaro.

Surpreendentemente, ninguém mencionou que vários (por exemplo,não relacionadas com o número de executando o sistema operacional em nível de threads) pilhas de chamadas são para ser encontrados não apenas em línguas exóticas (PostScript) ou plataformas de Intel (Intel Itanium), mas também em fibras, green threads e algumas implementações de co-rotinas.

Fibras, green threads e co-rotinas são, em muitos aspectos semelhantes, o que leva a uma grande confusão.A diferença entre fibras e verde threads é que o ex-uso cooperativo multitarefa, enquanto o último pode dispõem de cooperação ou de preferência em uma (ou ambas).Para a distinção entre fibras e co-rotinas, consulte aqui.

Em qualquer caso, a finalidade de ambas as fibras, green threads e co-rotinas é ter várias funções em execução simultaneamente, mas não em paralelo (ver este ENTÃO pergunta para a distinção) dentro de um único sistema operacional em nível de thread, a transferência de controle para trás e para a frente um do outro de uma forma organizada.

Quando utilizar fibras, green threads ou co-rotinas, você normalmente tem uma pilha separada por função.(Tecnicamente, não apenas uma pilha, mas todo um contexto de execução é de acordo com a função.O mais importante, registradores de CPU.) Para cada thread não somos, como muitos stacks como não estamos em simultâneo funções de execução, e a thread está alternando entre a execução de cada função, de acordo com a lógica do seu programa.Quando uma função é executada até o seu fim, a sua pilha é destruído.Assim, o número e a vida das pilhas são dinâmicos e não são determinadas pelo número de nível de sistema operacional threads!

Note que eu disse "normalmente tem uma pilha separada por função".Há tanto stackful e stackless implementações de couroutines.O mais notável stackful C++ são Impulso.Co-rotina e Microsoft PPL's async/await.(No entanto, o C++'s funções retornáveis (uma.k.um."async e await"), que foram propostas para C++17, são propensos a usar stackless co-rotinas.)

Fibras proposta para a biblioteca padrão C++ está próxima.Além disso, há algumas terceiros bibliotecas.Green threads são extremamente populares em linguagens como Python e Ruby.

Eu tenho algo para compartilhar, embora os principais pontos já estão cobertos.

Pilha

Acesso muito rápido.
Armazenados na memória RAM.
Chamadas de função são carregados aqui, juntamente com as variáveis locais e os parâmetros de função passado.
O espaço é liberado automaticamente quando o programa sai do escopo.
Armazenados na memória sequencial.

Pilha

Acesso lento comparativamente à Pilha.
Armazenados na memória RAM.
Criado dinamicamente variáveis são armazenadas aqui, que mais tarde requer liberar a memória alocada após o uso.
Armazenado sempre que a alocação de memória é feito, acessado pelo ponteiro sempre.

Nota interessante:

Devem as chamadas de função tinha sido armazenado na pilha, ter-se-ia resultou em 2 confuso pontos:
1. Devido ao sequencial de armazenamento na pilha, a execução é mais rápida.Armazenamento em pilha teria resultado em grande consumo de tempo, fazendo assim todo o programa de execução mais lenta.
2. Se as funções forem armazenados na pilha (confuso armazenamento apontada pelo ponteiro), não teria sido possível para voltar para o endereço do emissor de volta (que pilha dá devido ao sequencial de armazenamento em memória).

Um monte de respostas estão corretas, como conceitos, mas devemos notar que uma pilha é necessário para o hardware (i.e.microprocessador) para permitir a chamada de sub-rotinas (CHAMADA em linguagem assembly..).(OOP caras vão chamá-lo de métodos)

Na pilha para guardar os endereços de retorno e de chamada → premir p / ret → pop é gerenciado diretamente no hardware.

Você pode usar a pilha para passagem de parâmetros.mesmo se for mais lenta do que usando registradores (seria um microprocessador guru dizer ou uma boa 1980 BIOS livro. (...)

Sem pilha nenhum microprocessador pode trabalhar.(nós não podemos imaginar um programa, mesmo em linguagem assembly, sem sub-rotinas/funções)
Sem a pilha pode.(Um programa de linguagem assembly pode trabalhar sem o, como a pilha é um sistema operacional do conceito, como malloc, que é um sistema operacional/Lib chamada.

O uso de pilha é mais rápida:

É um hardware, e até mesmo push/pop são muito eficientes.
malloc requer entrar em modo kernel, use o bloqueio/semáforo (ou outros primitivos de sincronização) executar algum código e a gestão de algumas estruturas necessárias para manter o controle de alocação.

Wow!Tantas respostas e eu não acho que um deles deu certo...

1) Onde e o que são eles que (fisicamente em uma verdadeira memória do computador)?

A pilha é a memória que começa como o mais alto endereço de memória alocado para o seu programa de imagem e, em seguida, diminuir em valor a partir de lá.Ela é reservada para os chamados parâmetros de função e para todas as variáveis temporárias usadas em funções.

Existem duas pilhas:públicas e privadas.

Pilha particular começa em um limite de 16 bytes (para programas de 64 bits) ou um limite de 8 bytes (para programas de 32 bits) após o último byte de código no seu programa e, em seguida, aumenta de valor a partir de lá.Ele também é chamado de pilha padrão.

Se a pilha particular é muito grande ele irá se sobrepor a área de pilha, como pilha de sobrepor-se a pilha se fica muito grande.Porque a pilha inicia com uma maior endereço de e trabalha o seu caminho para baixo para abaixar o endereço, com a devida hacking você pode começar a tornar a pilha tão grande que não irá sobrecarregar a memória privada e área de sobreposição, o código de área.O truque, então, é a sobrepor-se o suficiente da área de código que você pode ligar para o código.É um pouco complicada de se fazer e você corre o risco de uma falha do programa, mas é fácil e muito eficaz.

O público pilha reside em seu próprio espaço de memória para fora do seu programa de espaço de imagem.É essa memória que vai ser desviados para o disco rígido se a memória obter recursos escassos.

2) até que ponto eles são controlados pelo sistema ou de tempo de execução idioma?

A pilha é controlado pelo programador, a memória privada é gerenciado pelo sistema operacional, e o público pilha não é controlado por ninguém, porque é um sistema operacional de serviço -- você fazer pedidos e eles são concedidos ou negados.

2b) Qual é o seu âmbito de aplicação?

Todos eles são globais para o programa, mas seu conteúdo pode ser público, privado ou global.

2c) o Que determina o tamanho de cada um deles?

O tamanho da pilha e o heap particular são determinados pelo compilador opções de tempo de execução.O público pilha é inicializado em tempo de execução usando um parâmetro de tamanho.

2d), o Que torna mais rápido?

Eles não são projetados para ser rápido, eles são projetados para ser útil.Como o programador utiliza-los determina se eles são "rápido" ou "lento"

REF:

https://norasandler.com/2019/02/18/Write-a-Compiler-10.html

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-getprocessheap

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-heapcreate

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow