_malloca_malloca

Asigna memoria en la pila.Allocates memory on the stack. Se trata de una versión de _alloca con mejoras de seguridad, como se describe en Características de seguridad de CRT.This is a version of _alloca with security enhancements as described in Security Features in the CRT.

SintaxisSyntax

void *_malloca(
   size_t size
);

ParámetrosParameters

sizesize
Bytes que se van a asignar desde la pila.Bytes to be allocated from the stack.

Valor devueltoReturn Value

La rutina _malloca devuelve un void puntero al espacio asignado, cuya alineación es adecuada para el almacenamiento de cualquier tipo de objeto.The _malloca routine returns a void pointer to the allocated space, which is guaranteed to be suitably aligned for storage of any type of object. Si el tamaño es 0, _malloca asigna un elemento de longitud cero y devuelve un puntero válido a ese elemento.If size is 0, _malloca allocates a zero-length item and returns a valid pointer to that item.

Si el tamaño es mayor que _ALLOCA_S_THRESHOLD, _malloca intenta asignar en el montón y devuelve un puntero nulo si no se puede asignar el espacio.If size is greater than _ALLOCA_S_THRESHOLD, then _malloca attempts to allocate on the heap, and returns a null pointer if the space can't be allocated. Si el tamaño es menor o igual que _ALLOCA_S_THRESHOLD, _malloca intenta asignar en la pila y se genera una excepción de desbordamiento de pila si no se puede asignar el espacio.If size is less than or equal to _ALLOCA_S_THRESHOLD, then _malloca attempts to allocate on the stack, and a stack overflow exception is generated if the space can't be allocated. La excepción de desbordamiento de pila no es una excepción de C++; se trata de una excepción estructurada.The stack overflow exception isn't a C++ exception; it's a structured exception. En lugar de usar el control de excepciones de C++, debe usar el control de excepciones estructurado (SEH) para detectar esta excepción.Instead of using C++ exception handling, you must use Structured Exception Handling (SEH) to catch this exception.

ObservacionesRemarks

_malloca asigna bytes de tamaño de la pila del programa o del montón si la solicitud supera un determinado tamaño en bytes dado por _ALLOCA_S_THRESHOLD._malloca allocates size bytes from the program stack or the heap if the request exceeds a certain size in bytes given by _ALLOCA_S_THRESHOLD. La diferencia entre _malloca y _alloca es que _alloca siempre asigna en la pila, independientemente del tamaño.The difference between _malloca and _alloca is that _alloca always allocates on the stack, regardless of the size. A diferencia de _alloca, que no requiere ni permite una llamada a Free para liberar la memoria de modo que se asigne , _malloca requiere el uso de _freea para liberar memoria.Unlike _alloca, which does not require or permit a call to free to free the memory so allocated, _malloca requires the use of _freea to free memory. En el modo de depuración, _malloca siempre asigna memoria del montón.In debug mode, _malloca always allocates memory from the heap.

Existen restricciones para llamar explícitamente a _malloca en un controlador de excepciones (EH).There are restrictions to explicitly calling _malloca in an exception handler (EH). Las rutinas del controlador de excepciones que se ejecutan en procesadores de clase x86 funcionan en su propio marco de memoria: llevan a cabo sus tareas en el espacio de memoria que no se basa en la ubicación actual del puntero de pila de la función de inclusión.EH routines that run on x86-class processors operate in their own memory frame: They perform their tasks in memory space that is not based on the current location of the stack pointer of the enclosing function. Las implementaciones más habituales incluyen el control de excepciones estructuradas (SEH) de Windows NT y las expresiones de la cláusula catch de C++.The most common implementations include Windows NT structured exception handling (SEH) and C++ catch clause expressions. Por consiguiente, si se llama explícitamente a _malloca en cualquiera de los siguientes escenarios, se produce un error en el programa durante la devolución a la rutina de llamada EH:Therefore, explicitly calling _malloca in any of the following scenarios results in program failure during the return to the calling EH routine:

  • Expresión de filtro de excepciones SEH de Windows NT: __except ( _malloca () )Windows NT SEH exception filter expression: __except (_malloca () )

  • Controlador de excepciones final de SEH de Windows NT: __finally { _malloca () }Windows NT SEH final exception handler: __finally {_malloca () }

  • Expresión de la cláusula catch del controlador de excepciones de C++C++ EH catch clause expression

Sin embargo, se puede llamar a _malloca directamente desde una rutina EH o desde una devolución de llamada proporcionada por la aplicación que se invoca mediante uno de los escenarios EH descritos anteriormente.However, _malloca can be called directly from within an EH routine or from an application-supplied callback that gets invoked by one of the EH scenarios previously listed.

Importante

En Windows XP, si se llama a _malloca dentro de un bloque try/catch, debe llamar a _resetstkoflw en el bloque catch.In Windows XP, if _malloca is called inside a try/catch block, you must call _resetstkoflw in the catch block.

Además de las restricciones anteriores, al usar la opción /CLR (compilación de Common Language Runtime) , _malloca no se pueden usar en __except bloques.In addition to the above restrictions, when using the /clr (Common Language Runtime Compilation) option, _malloca cannot be used in __except blocks. Para obtener más información, vea Restricciones de /clr.For more information, see /clr Restrictions.

RequisitosRequirements

RutinaRoutine Encabezado necesarioRequired header
_malloca_malloca <malloc.h>

Ejemplo: inlocateExample: 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();
}

Ejemplo: Exception (excepción)Example: malloca exception

// 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);
        }
    };
}

EntradaInput

1000

Salida de ejemploSample Output

Enter the number of bytes to allocate using _malloca: 1000

Vea tambiénSee also

Asignación de memoriaMemory Allocation
calloccalloc
mallocmalloc
reallocrealloc
_resetstkoflw_resetstkoflw