Muitas respostas interessantes para essa pergunta "antiga", até algumas respostas relativamente novas, mas não encontrei nenhuma que mencionasse isso ...
Quando usado de maneira adequada e cuidadosa, o uso consistente alloca()
(talvez em todo o aplicativo) para lidar com pequenas alocações de tamanho variável (ou C99 VLAs, quando disponíveis) pode levar a um crescimento geral menor da pilha do que uma implementação equivalente usando matrizes locais de tamanho fixo de tamanho fixo . Portanto, alloca()
pode ser bom para sua pilha se você a usar com cuidado.
Encontrei essa citação em ... OK, fiz essa citação. Mas realmente, pense nisso ....
@j_random_hacker está muito certo em seus comentários sob outras respostas: Evitar o uso de a alloca()
favor de matrizes locais superdimensionadas não torna seu programa mais seguro contra estouros de pilha (a menos que seu compilador tenha idade suficiente para permitir a inclusão de funções usadas alloca()
nesse caso, você deve atualização, ou a menos que você use alloca()
loops internos; nesse caso, você não deve ... usar alloca()
loops internos).
Trabalhei em ambientes de desktop / servidor e sistemas embarcados. Muitos sistemas embarcados nem sequer usam um heap (eles nem se vinculam no suporte a ele), por motivos que incluem a percepção de que a memória alocada dinamicamente é ruim devido aos riscos de vazamento de memória em um aplicativo que nunca sempre reinicia por anos, ou a justificativa mais razoável de que a memória dinâmica é perigosa porque não se pode ter certeza de que um aplicativo nunca fragmentará sua pilha ao ponto de falsa exaustão de memória. Portanto, os programadores incorporados ficam com poucas alternativas.
alloca()
(ou VLAs) pode ser a ferramenta certa para o trabalho.
Eu vi várias vezes em que um programador cria um buffer alocado para a pilha "grande o suficiente para lidar com qualquer caso possível". Em uma árvore de chamada profundamente aninhada, o uso repetido desse padrão (anti -?) Leva ao uso exagerado da pilha. (Imagine uma árvore de chamadas com 20 níveis de profundidade, onde, em cada nível, por diferentes razões, a função superaloca cegamente um buffer de 1024 bytes "apenas por segurança", quando geralmente usa apenas 16 ou menos deles, e apenas em casos raros podem usar mais.) Uma alternativa é usaralloca()
ou VLAs e aloque apenas o espaço de pilha necessário para sua função, para evitar sobrecarregar desnecessariamente a pilha. Felizmente, quando uma função na árvore de chamadas precisa de uma alocação maior que o normal, outras ainda estão usando suas alocações pequenas normais e o uso geral da pilha de aplicativos é significativamente menor do que se todas as funções superalocassem cegamente um buffer local .
Mas se você optar por usar alloca()
...
Com base em outras respostas nesta página, parece que os VLAs devem ser seguros (eles não compõem alocações de pilha se chamados de dentro de um loop), mas se você estiver usando alloca()
, tenha cuidado para não usá-lo dentro de um loop e faça verifique se sua função não pode ser incorporada se houver alguma chance de ser chamada no loop de outra função.