_malloca

Aloca memória na pilha. Essa função é uma versão do com aprimoramentos de _alloca segurança, conforme descrito em Recursos de segurança no CRT.

Sintaxe

void *_malloca(
   size_t size
);

Parâmetros

size
Bytes a serem alocados da pilha.

Valor retornado

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

Se size for maior que _ALLOCA_S_THRESHOLD, _malloca tentará alocar no heap e retornará um ponteiro nulo se o espaço não puder ser alocado. Se size for menor ou igual a _ALLOCA_S_THRESHOLD, _malloca tentará alocar na pilha e uma exceção de excedente de pilha será gerada se o espaço não puder ser alocado. 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 SEH (tratamento de exceção estruturado) para capturar essa exceção.

Comentários

O _malloca alocará size bytes da pilha ou do heap do programa se a solicitação exceder um determinado tamanho em bytes fornecidos pelo _ALLOCA_S_THRESHOLD. A diferença entre _malloca e _alloca é que o _alloca sempre aloca na pilha, independentemente do tamanho. Ao contrário de _alloca, que não exige nem permite que uma chamada para free libere a memória alocada, _malloca exige o uso de _freea para liberar memória. No modo de depuração, o _malloca sempre aloca memória do heap.

Há restrições para chamar _malloca 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 SEH (Manipulação de Exceção Estruturada ) do Windows NT e expressões de cláusula catch de C++. Portanto, chamar _malloca explicitamente em qualquer um dos seguintes cenários resulta em falha do programa durante o retorno ao chamar a rotina EH:

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

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

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

No entanto, _malloca 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

No Windows, se _malloca for chamado dentro de um try/catch bloco, você deve chamar _resetstkoflw o bloco catch.

Além das restrições acima, ao usar a /clr opção _malloca (Common Language Runtime Compilation), não pode ser usado em __except blocos. Para obter mais informações, consulte /clr Restrições.

Requisitos

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

Exemplo: _malloca

// crt_malloca_simple.c
#include <stdio.h>
#include <malloc.h>

void Fn()
{
   char * buf = (char *)_malloca( 100 );
   // do something with buf
   _freea( buf );
}

int main()
{
   Fn();
}

Exemplo: _malloca exceção

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

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

int main()
{
    int     size;
    int     numberRead = 0;
    int     errcode = 0;
    void    *p = NULL;
    void    *pMarker = NULL;

    while (numberRead == 0)
    {
        printf_s("Enter the number of bytes to allocate "
                 "using _malloca: ");
        numberRead = scanf_s("%d", &size);
    }

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

    __try
    {
        if (size > 0)
        {
            p =  _malloca( size );
        }
        else
        {
            printf_s("Size must be a positive number.");
        }
        _freea( p );
    }

    // Catch any exceptions that may occur.
    __except( GetExceptionCode() == STATUS_STACK_OVERFLOW )
    {
        printf_s("_malloca failed!\n");

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

Entrada

1000

Saída de exemplo

Enter the number of bytes to allocate using _malloca: 1000

Confira também

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