_alloca

Artigo
08/25/2010

Aloca memória na pilha.Esta função é desaprovada porque uma versão mais segura disponível; consulte _malloca.

void *_alloca( 
   size_t size 
);

Parâmetros

[in]size
Bytes a ser alocada da pilha.

Valor de retorno

The _alloca rotina retorna uma void ponteiro para o espaço alocado, tem a garantia de ser alinhadas adequadamente para o armazenamento de qualquer tipo de objeto. If size é 0, _alloca aloca um item de comprimento zero e retorna um ponteiro válido para esse item.

Uma exceção de estouro de pilha é gerada se o espaço não pode ser alocado.A exceção de estouro de pilha não é uma exceção de C++; é uma exceção estruturada.Em vez de usar o tratamento de exceção de C++, você deve usar Manipulação de exceção estruturada (SEH).

Comentários

_alloca aloca size bytes da pilha de programa. O espaço alocado é liberado automaticamente quando a função de chamada é encerrado (não quando a alocação simplesmente passa fora do escopo).Portanto, não passar o valor de ponteiro retornado por _alloca sistema autônomo um argumento para disponível.

Há restrições para chamar explicitamente _alloca em um manipulador de exceção (EH). Rotinas EH executados no x86 - classe processadores operam em seu próprio quadro de memória: Eles executam suas tarefas no espaço de memória que não esteja baseado no local corrente do ponteiro de pilha da função delimitador.Implementações mais comuns incluem o Windows NT estruturada (SEH) de manipulação de exceção e expressões de cláusula catch C++.Portanto, chamar explicitamente _alloca em qualquer um dos seguintes resultados cenários em falha de programa durante o retorno para chamar a rotina EH:

Expressão de filtro de exceção SEH Windows NT: __except (_alloca () )
Manipulador de exceção final de SEH do Windows NT: __finally {_alloca () }
Expressão de cláusula catch C++ EH

No entanto, _alloca pode ser chamado diretamente a partir de uma rotina de EH ou de um retorno de chamada fornecido pelo aplicativo que é invocado por um dos cenários de EH listados anteriormente.

Observação de segurança:
No Windows XP, se _alloca é chamado dentro de um bloco try/catch, você deve chamar _resetstkoflw no bloco catch.

Juntamente com as restrições acima, ao usar o CLR (common linguagem tempo de execução Compilation) option, _alloca não pode ser usado em __except blocos. Para obter mais informações, consulte /CLR restrições.

Requisitos

Rotina	Cabeçalho necessário
_alloca	<malloc.h>

Exemplo

// crt_alloca.c
// This program demonstrates the use of
// _alloca and trapping any exceptions
// that may occur.

#include <windows.h>
#include <stdio.h>
#include <malloc.h>

int main()
{
    int     size = 1000;
    int     errcode = 0;
    void    *pData = NULL;

    // Note: Do not use try/catch for _alloca,
    // use __try/__except, since _alloca throws
    // Structured Exceptions, not C++ exceptions.

    __try {
        // An unbounded _alloca can easily result in a 
        // stack overflow.
        // Checking for a size < 1024 bytes is recommended.
        if (size > 0 && size < 1024)
        {
            pData = _alloca( size );
            printf_s( "Allocated %d bytes of stack at 0x%p",
                      size, pData);
        }
        else
        {
            printf_s("Tried to allocate too many bytes.\n");
        }
    }

    // If an exception occured with the _alloca function
    __except( GetExceptionCode() == STATUS_STACK_OVERFLOW )
    {
        printf_s("_alloca failed!\n");

        // If the stack overflows, use this function to restore.
        errcode = _resetstkoflw();
        if (errcode)
        {
            printf_s("Could not reset the stack!\n");
            _exit(1);
        }
    };
}

Allocated 1000 bytes of stack at 0x0012FB50