_alloca

Aloca memória na pilha. Essa função foi preterida pois uma versão mais segura está disponível; confira _malloca.

Sintaxe

void *_alloca(
   size_t size
);

Parâmetros

size
Bytes a serem alocados da pilha.

Retornar valor

A _alloca rotina retorna um void ponteiro para o espaço alocado, que é alinhado adequadamente para armazenamento de qualquer tipo de objeto. Se size for 0, o _alloca alocará um item de comprimento zero e retornará um ponteiro válido para esse item.

Uma exceção de excedente de pilha será gerada se não for possível alocar o espaço. A exceção de excedente de pilha não é uma exceção do C++; ela é uma exceção estruturada. Em vez de usar o tratamento de exceções C++, você deve usar o tratamento de exceções estruturadas (SEH).

Comentários

_alloca aloca size bytes da pilha de programas. O espaço alocado é liberado automaticamente quando a função de chamada é encerrada (não quando a alocação simplesmente sai do escopo). Portanto, não passe o valor de ponteiro retornado por _alloca como um argumento para free.

Há restrições para chamar _alloca explicitamente em um EH (manipulador de exceção). As rotinas do EH que são executadas em processadores da classe x86 operam em seu próprio quadro de memória: elas realizam as tarefas no espaço de memória que não é baseado no local atual do ponteiro de pilha da função delimitadora. As implementações mais comuns incluem o SEH (tratamento de exceções estruturadas) do Windows e expressões de cláusula catch do C++. Portanto, chamar _alloca explicitamente em qualquer um dos seguintes cenários resulta em falha do programa durante o retorno ao chamar a rotina EH:

• Expressão do filtro de exceção SEH do Windows: __except ( _alloca() )

• Manipulador de exceção final do Windows SEH: __finally { _alloca() }

• Expressão da cláusula catch do EH de C++

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

Importante

Se _alloca for chamado dentro de um bloco try, você deve chamar _resetstkoflw o bloco catch.

Além das restrições acima, ao usar a opção /clr (Compilação do Common Language Runtime), o _alloca não poderá ser usado nos blocos __except. 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 occurred 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 == 0) //  _resetstkoflw() returns 0 on failure
        {
            printf_s("Could not reset the stack!\n");
            _exit(1);
        }
    };
}

Allocated 1000 bytes of stack at 0x0012FB50

Confira também

Alocação de memória
calloc
malloc
realloc
_resetstkoflw
_malloca