stackalloc (référence C#)stackalloc (C# Reference)

Le mot clé stackalloc sert à allouer un bloc de mémoire sur la pile.The stackalloc keyword is used to allocate a block of memory on the stack.

Span<int> block = stackalloc int[100];

Le fait d’affecter le bloc alloué à un Span<T> au lieu d’un int* permet d’effectuer des allocations de pile dans un bloc safe.Assigning the allocated block to a Span<T> instead of an int* allows stack allocations in a safe block. Le contexte unsafe n’est pas obligatoire.The unsafe context is not required.

RemarquesRemarks

Le mot clé est valide uniquement dans les initialiseurs de variable locale.The keyword is valid only in local variable initializers. Le code suivant génère des erreurs de compilation.The following code causes compiler errors.

int* block;
// The following assignment statement causes compiler errors. You
// can use stackalloc only when declaring and initializing a local
// variable.
block = stackalloc int[100];
Span<int> span;
// The following assignment statement causes compiler errors. You
// can use stackalloc only when declaring and initializing a local
// variable.
span = stackalloc int[100];

Dans C# 7.3 et les versions ultérieures, vous pouvez utiliser la syntaxe d’initialiseur de tableau pour les tableaux stackalloc.Beginning with C# 7.3, you can use array initializer syntax for stackalloc arrays. Toutes les déclarations suivantes déclarent un tableau de trois éléments ayant pour valeurs les entiers 1, 2 et 3.All the following declarations declare an array with three elements whose values are the integers 1, 2, and 3. La deuxième initialisation attribue la mémoire à un ReadOnlySpan<T>, indiquant que celle-ci n’est pas modifiable.The second initialization assigns the memory to a ReadOnlySpan<T>, indicating that the memory cannot be modified.

// Valid starting with C# 7.3
Span<int> first = stackalloc int[3] { 1, 2, 3 };
ReadOnlySpan<int> second = stackalloc int[] { 1, 2, 3 };
Span<int> third = stackalloc[] { 1, 2, 3 };

Quand des types pointeur sont impliqués, stackalloc exige un contexte unsafe.When pointer types are involved, stackalloc requires an unsafe context. Pour plus d’informations, consultez Pointeurs et code unsafe.For more information, see Unsafe Code and Pointers.

stackalloc est similaire à _alloca dans la bibliothèque runtime C.is like _alloca in the C run-time library.

ExemplesExamples

L’exemple suivant calcule et affiche les 20 premiers nombres de la suite de Fibonacci.The following example calculates and displays the first 20 numbers in the Fibonacci sequence. Chaque nombre est la somme des deux nombres précédents.Each number is the sum of the previous two numbers. Dans le code, un bloc de mémoire de taille suffisante pour contenir 20 éléments de type int est alloué sur la pile, et non sur le tas.In the code, a block of memory of sufficient size to contain 20 elements of type int is allocated on the stack, not the heap. L’adresse du bloc est stockée dans le Span fib.The address of the block is stored in the Span fib. Cette mémoire n’est pas soumise au garbage collection et n’est donc pas tenue d’être épinglée (en utilisant fixed).This memory is not subject to garbage collection and therefore does not have to be pinned (by using fixed). La durée de vie du bloc de mémoire est limitée à la durée de vie de la méthode qui le définit.The lifetime of the memory block is limited to the lifetime of the method that defines it. Vous ne pouvez pas libérer la mémoire avant le retour de la méthode.You cannot free the memory before the method returns.

const int arraySize = 20;
Span<int> fib = stackalloc int[arraySize];
// The sequence begins with 1, 1.
fib[0] = fib[1] = 1;
for (int i = 2; i < arraySize; ++i)
{
    // Sum the previous two numbers.
    fib[i] = fib[i-1] + fib[i-2];
}
for (int i = 0; i < arraySize; ++i)
{
    Console.WriteLine(fib[i]);
}
/* Output:
   1
   1
   2
   3
   5
   8
   13
   21
   34
   55
   89
   144
   233
   377
   610
   987
   1597
   2584
   4181
   6765
 */

L’exemple suivant initialise un tableau stackalloc d’entiers sur un masque de bits où un bit est défini dans chaque élément.The following example initializes a stackalloc array of integers to a bit mask with one bit set in each element. Cela illustre la nouvelle syntaxe d’initialiseur disponible à partir de C# 7.3 :This demonstrates the new initializer syntax available starting in C# 7.3:

ReadOnlySpan<int> mask = stackalloc[] {
    0b_0000_0000_0000_0001,
    0b_0000_0000_0000_0010,
    0b_0000_0000_0000_0100,
    0b_0000_0000_0000_1000,
    0b_0000_0000_0001_0000,
    0b_0000_0000_0010_0000,
    0b_0000_0000_0100_0000,
    0b_0000_0000_1000_0000,
    0b_0000_0001_0000_0000,
    0b_0000_0010_0000_0000,
    0b_0000_0100_0000_0000,
    0b_0000_1000_0000_0000,
    0b_0001_0000_0000_0000,
    0b_0010_0000_0000_0000,
    0b_0100_0000_0000_0000,
    0b_1000_0000_0000_0000
};

for (int i = 0; i < 16; i++)
    Console.WriteLine(mask[i]);
/* Output:
   1
   2
   4
   8
   16
   32
   64
   128
   256
   512
   1024
   2048
   4096
   8192
   16384
   32768
 */

SécuritéSecurity

Utilisez Span<T> ou ReadOnlySpan<T> dans la mesure du possible, car le code unsafe est moins sécurisé que son équivalent safe.You should use Span<T> or ReadOnlySpan<T> when possible because unsafe code is less secure than safe alternatives. Même avec des pointeurs, stackalloc active automatiquement les fonctionnalités de détection des dépassements de mémoire tampon dans le Common Language Runtime (CLR).Even when used with pointers, the use of stackalloc automatically enables buffer overrun detection features in the common language runtime (CLR). Si un dépassement de mémoire tampon est détecté, le processus est terminé aussi rapidement que possible pour réduire les risques d’exécution de code malveillant.If a buffer overrun is detected, the process is terminated as quickly as possible to minimize the chance that malicious code is executed.

spécification du langage C#C# language specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also