_alloca

Alloue de la mémoire sur la pile. Cette fonction est déconseillée, car une version plus sécurisée est disponible ; voir _malloca.

Syntaxe

void *_alloca(
   size_t size
);

Paramètres

size
Octets à allouer à partir de la pile.

Valeur retournée

La _alloca 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, _alloca alloue un élément de longueur nulle et retourne un pointeur valide vers cet élément.

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).

Notes

_alloca alloue des octets size de la pile de programmes. L’espace alloué est libéré automatiquement lorsque la fonction appelante quitte (et non lorsque l’allocation passe simplement hors de portée). Par conséquent, ne passez pas la valeur de pointeur retournée par _alloca un argument à free.

Des restrictions s’appliquent à l’appel explicite de _alloca 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 la gestion des exceptions structurées Windows (SEH) et les expressions de clause catch C++. Ainsi, appeler explicitement _alloca 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 ( _alloca() )

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

• Expression de clause catch EH C++

Toutefois, _alloca 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.

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

Spécifications

Exemple

// 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

Voir aussi

Allocation de mémoire
calloc
malloc
realloc
_resetstkoflw
_malloca