_malloca

Allokerar minne på stacken. Den här funktionen är en version av _alloca med säkerhetsförbättringar enligt beskrivningen i Säkerhetsfunktioner i CRT.

Syntax

void *_malloca(
   size_t size
);

Parameterar

size
Byte som ska allokeras från stacken.

Returvärde

Rutinen _malloca returnerar en void pekare till det allokerade utrymmet, som är lämpligt justerat för lagring av alla typer av objekt. Om size är 0 _malloca allokerar ett objekt med noll längd och returnerar en giltig pekare till objektet.

Om size är större än _ALLOCA_S_THRESHOLDförsöker du _malloca allokera på heapen och returnerar en null-pekare om utrymmet inte kan allokeras. Om size är mindre än eller lika med _ALLOCA_S_THRESHOLDförsöker du _malloca allokera på stacken och ett stacköverflödesfel genereras om utrymmet inte kan allokeras. Undantaget stackspill är inte ett C++-undantag. det är ett strukturerat undantag. I stället för att använda C++-undantagshantering måste du använda SEH (Structured exception handling ) för att fånga upp det här undantaget.

Anmärkningar

_malloca allokerar size byte från programstacken eller heapen om begäran överskrider en viss storlek i byte som anges av _ALLOCA_S_THRESHOLD. Skillnaden mellan _malloca och _alloca är att _alloca alltid allokeras på stacken, oavsett storlek. Till skillnad från _alloca, som inte kräver eller tillåter ett anrop till för att free frigöra minnet så allokerat, _malloca kräver användning av _freea för att frigöra minne. I felsökningsläge _malloca allokerar du alltid minne från heapen.

Det finns begränsningar för att uttryckligen anropa _malloca i en undantagshanterare (EH). EH-rutiner som körs på x86-klassprocessorer fungerar i sin egen minnesram: De utför sina uppgifter i minnesutrymmet som inte baseras på den aktuella platsen för stackpekaren för den omslutande funktionen. De vanligaste implementeringarna är windows NT-strukturerad undantagshantering (SEH) och C++-catch-satsuttryck. Därför resulterar explicit anrop _malloca i något av följande scenarier i programfel under återgången till den anropande EH-rutinen:

• Windows SEH-undantagsfilteruttryck: __except (_malloca ())

• Windows SEH slutlig undantagshanterare: __finally {_malloca () }

• C++ EH catch-satsuttryck

Kan dock _malloca anropas direkt från en EH-rutin eller från ett återanrop från program som anropas av något av de EH-scenarier som tidigare angavs.

Viktigt!

Om anropas i ett _malloca block i Windows try/catch måste du anropa _resetstkoflw i catch-blocket.

Förutom ovanstående begränsningar kan du inte använda alternativet (Common Language Runtime-kompilering) i block när du använder/clr alternativet_malloca (Common Language Runtime Compilation).__except Mer information finns i /clr Begränsningar.

Kravspecifikation

Rutin	Obligatoriskt huvud
_malloca	<malloc.h>

Exempel: _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();
}

Exempel: _malloca undantag

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

Inmatning

1000

Exempelresultat

Enter the number of bytes to allocate using _malloca: 1000

Se även

minnesallokering
calloc
malloc
realloc
_resetstkoflw