Exporter (0) Imprimer
Développer tout

Stack<T>, classe

Mise à jour : November 2007

Représente une collection de type dernier entré premier sorti de taille variable d'instances du même type arbitraire.

Espace de noms :  System.Collections.Generic
Assembly :  System (dans System.dll)

[SerializableAttribute]
[ComVisibleAttribute(false)]
public class Stack<T> : IEnumerable<T>, ICollection, 
	IEnumerable

J# prend en charge l'utilisation d'API génériques mais pas la déclaration de nouvelles API.
JScript ne prend pas en charge les types ou les méthodes génériques.

Paramètres de type

T

Spécifie le type d'éléments dans la pile.

Stack<T> est implémenté sous la forme d'un tableau.

La capacité de Stack<T> correspond au nombre d'éléments que peut contenir Stack<T>. Lorsque des éléments sont ajoutés à Stack<T>, la capacité est automatiquement augmentée, si nécessaire, en réallouant le tableau interne. Cette capacité peut diminuer en appelant TrimExcess.

Si Count est inférieur à la capacité de la pile, Push est une opération O(1). Si la capacité doit être augmentée pour intégrer le nouvel élément, Push devient une opération O(n), où n est égal à Count. Pop est une opération O(1).

Stack<T> accepte null comme valeur valide pour les types référence et autorise les éléments en double.

L'exemple de code suivant illustre de nombreuses méthodes de la classe générique Stack<T>. L'exemple de code crée une pile de chaînes avec une capacité par défaut et utilise la méthode Push pour insérer cinq chaînes dans la pile. Les éléments de la pile sont énumérés, ce qui ne modifie pas l'état de la pile. La méthode Pop permet d'exécuter un pop sur la première chaîne pour l'enlever de la pile. La méthode Peek permet d'afficher l'élément suivant sur la pile, et la méthode Pop permet d'exécuter un pop sur cet élément pour l'enlever.

La méthode ToArray permet de créer un tableau et d'y copier les éléments de la pile. Ce tableau est ensuite passé au constructeur Stack<T> qui accepte IEnumerable<T>, créant ainsi une copie de la pile dont l'ordre des éléments est inversé. Les éléments de la copie s'affichent.

Un tableau représentant deux fois la taille de la pile est créé, et la méthode CopyTo est utilisée pour copier les éléments du tableau commençant au milieu du tableau. Le constructeur Stack<T> est utilisé à nouveau pour créer une copie de la pile dont l'ordre des éléments est inversé ; par conséquent, les trois éléments null figurent à la fin.

La méthode Contains permet d'indiquer que la chaîne "four" figure dans la première copie de la pile. La méthode Clear efface ensuite la copie et la propriété Count indique que la pile est vide.

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Stack<string> numbers = new Stack<string>();
        numbers.Push("one");
        numbers.Push("two");
        numbers.Push("three");
        numbers.Push("four");
        numbers.Push("five");

        // A stack can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nPopping '{0}'", numbers.Pop());
        Console.WriteLine("Peek at next item to destack: {0}", 
            numbers.Peek());
        Console.WriteLine("Popping '{0}'", numbers.Pop());

        // Create a copy of the stack, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Stack<string> stack2 = new Stack<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in stack2 )
        {
            Console.WriteLine(number);
        }

        // Create an array twice the size of the stack and copy the
        // elements of the stack, starting at the middle of the 
        // array. 
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);

        // Create a second stack, using the constructor that accepts an
        // IEnumerable(Of T).
        Stack<string> stack3 = new Stack<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in stack3 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nstack2.Contains(\"four\") = {0}", 
            stack2.Contains("four"));

        Console.WriteLine("\nstack2.Clear()");
        stack2.Clear();
        Console.WriteLine("\nstack2.Count = {0}", stack2.Count);
    }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */


System.Object
  System.Collections.Generic.Stack<T>

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Stack<T> peut prendre simultanément en charge plusieurs lecteurs, tant que la collection n'est pas modifiée. Même dans ce cas, l'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Pour garantir la sécurité des threads pendant l'énumération, vous pouvez verrouiller la collection pendant toute la durée de cette opération. Pour permettre à plusieurs threads d'accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile pour Smartphone, Windows Mobile pour Pocket PC, Xbox 360

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0

.NET Compact Framework

Pris en charge dans : 3.5, 2.0

XNA Framework

Pris en charge dans : 2.0, 1.0

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2015 Microsoft