_malloca

Alloue de la mémoire sur la pile. Cette fonction est une version des améliorations de _alloca sécurité décrites dans les fonctionnalités de sécurité du CRT.

Syntaxe

void *_malloca(
   size_t size
);

Paramètres

size
Octets à allouer à partir de la pile.

Valeur retournée

La _malloca routine retourne un void pointeur vers l’espace alloué, qui est correctement aligné pour le stockage de n’importe quel type d’objet. Si size a la valeur 0, _malloca alloue un élément de longueur nulle et retourne un pointeur valide vers cet élément.

Si size elle est supérieure _ALLOCA_S_THRESHOLDà , tente d’allouer _malloca sur le tas et retourne un pointeur Null si l’espace ne peut pas être alloué. Si size elle est inférieure ou égale à _ALLOCA_S_THRESHOLD, tente _malloca d’allouer sur la pile et une exception de dépassement de capacité de pile est générée si l’espace ne peut pas être alloué. L’exception de dépassement de capacité de pile n’est pas une exception C++ ; il s’agit d’une exception structurée. Au lieu d’utiliser la gestion des exceptions C++, vous devez utiliser la gestion des exceptions structurées (SEH) pour intercepter cette exception.

Notes

_malloca alloue size octets à partir de la pile du programme ou du tas si la demande dépasse une certaine taille en octets fournie par _ALLOCA_S_THRESHOLD. La différence entre _malloca et _alloca est que _alloca alloue toujours sur la pile, indépendamment de la taille. Contrairement _allocaà , qui ne nécessite pas ou autorise un appel à free libérer la mémoire ainsi allouée, _malloca nécessite l’utilisation de _freea la mémoire libre. En mode débogage, _malloca alloue toujours de la mémoire à partir du tas.

Des restrictions s’appliquent à l’appel explicite de _malloca dans un gestionnaire d’exceptions (EH). Les routines EH qui s’exécutent sur des processeurs de classe x86 fonctionnent dans leur propre trame de mémoire : elles effectuent leurs tâches dans l’espace mémoire qui n’est pas basé sur l’emplacement actuel du pointeur de pile de la fonction englobante. Les implémentations les plus courantes incluent les expressions de gestion des exceptions structurées Windows NT (SEH) et les expressions de clause catch C++. Ainsi, appeler explicitement _malloca dans l’un des scénarios suivants entraîne l’échec du programme pendant le retour à la routine EH appelante :

• Expression de filtre d’exception Windows SEH : __except (_malloca () )

• Gestionnaire d’exceptions finale Windows SEH : __finally { }_malloca ()

• Expression de clause catch EH C++

Toutefois, _malloca peut être appelée directement à partir d’une routine EH ou à partir d’un rappel fourni par l’application appelé dans le cadre d’un des scénarios EH indiqués plus haut.

Important

Dans Windows, s’il _malloca est appelé à l’intérieur d’un try/catch bloc, vous devez appeler _resetstkoflw dans le bloc catch.

Outre les restrictions ci-dessus, lors de l’utilisation de l’option _malloca/clr (Compilation Common Language Runtime), ne peut pas être utilisée dans __except des blocs. Pour plus d’informations, consultez /clr Restrictions.

Spécifications

Routine	En-tête requis
_malloca	<malloc.h>

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

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

Entrée

1000

Exemple de sortie

Enter the number of bytes to allocate using _malloca: 1000

Voir aussi

Allocation de mémoire
calloc
malloc
realloc
_resetstkoflw