Stack Classe

Définition

Espace de noms:

System.Collections

Assembly:

System.Collections.NonGeneric.dll

Source:

Stack.cs

Représente une simple collection non générique d’objets de type dernier entré, premier sorti (LIFO).

public ref class Stack : ICloneable, System::Collections::ICollection

public class Stack : ICloneable, System.Collections.ICollection

type Stack = class
    interface ICollection
    interface IEnumerable
    interface ICloneable

Public Class Stack
Implements ICloneable, ICollection

Héritage

Object

Stack

Implémente

ICollection IEnumerable ICloneable

Exemples

L’exemple suivant montre comment créer et ajouter des valeurs à une pile et comment afficher ses valeurs.

using namespace System;
using namespace System::Collections;
void PrintValues( IEnumerable^ myCollection );
int main()
{
   
   // Creates and initializes a new Stack.
   Stack^ myStack = gcnew Stack;
   myStack->Push( "Hello" );
   myStack->Push( "World" );
   myStack->Push( "!" );
   
   // Displays the properties and values of the Stack.
   Console::WriteLine( "myStack" );
   Console::WriteLine( "\tCount:    {0}", myStack->Count );
   Console::Write( "\tValues:" );
   PrintValues( myStack );
}

void PrintValues( IEnumerable^ myCollection )
{
   IEnumerator^ myEnum = myCollection->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ obj = safe_cast<Object^>(myEnum->Current);
      Console::Write( "    {0}", obj );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 myStack
     Count:    3
     Values:    !    World    Hello
 */

using System;
using System.Collections;
public class SamplesStack  {

   public static void Main()  {

      // Creates and initializes a new Stack.
      Stack myStack = new Stack();
      myStack.Push("Hello");
      myStack.Push("World");
      myStack.Push("!");

      // Displays the properties and values of the Stack.
      Console.WriteLine( "myStack" );
      Console.WriteLine( "\tCount:    {0}", myStack.Count );
      Console.Write( "\tValues:" );
      PrintValues( myStack );
   }

   public static void PrintValues( IEnumerable myCollection )  {
      foreach ( Object obj in myCollection )
         Console.Write( "    {0}", obj );
      Console.WriteLine();
   }
}


/*
This code produces the following output.

myStack
    Count:    3
    Values:    !    World    Hello
*/

Imports System.Collections

Public Class SamplesStack    
    
    Public Shared Sub Main()
    
        ' Creates and initializes a new Stack.
        Dim myStack As New Stack()
        myStack.Push("Hello")
        myStack.Push("World")
        myStack.Push("!")
        
        ' Displays the properties and values of the Stack.
        Console.WriteLine("myStack")
        Console.WriteLine(ControlChars.Tab & "Count:    {0}", myStack.Count)
        Console.Write(ControlChars.Tab & "Values:")
        PrintValues(myStack)
    End Sub
    
    Public Shared Sub PrintValues(myCollection As IEnumerable)
        Dim obj As [Object]
        For Each obj In  myCollection
            Console.Write("    {0}", obj)
        Next obj
        Console.WriteLine()
    End Sub

End Class

' This code produces the following output.
'
' myStack
'     Count:     3
'     Values:    !    World    Hello

Remarques

La capacité d’un Stack est le nombre d’éléments que peut Stack contenir. À mesure que des éléments sont ajoutés à un Stack, la capacité est automatiquement augmentée en fonction des besoins par le biais de la réaffectation.

Important

Nous vous déconseillons d’utiliser la classe pour le Stack nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la classe générique System.Collections.Generic.Stack<T> . Pour plus d’informations, consultez Collections non génériques ne doivent pas être utilisées sur GitHub.

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

Stack accepte null comme valeur valide et autorise les éléments en double.

Constructeurs

Stack()	Initialise une nouvelle instance de la classe Stack qui est vide et possède la capacité initiale par défaut.
Stack(ICollection)	Initialise une nouvelle instance de la classe Stack qui contient des éléments copiés à partir de la collection spécifiée et qui possède la capacité initiale correspondant au nombre d'éléments copiés.
Stack(Int32)	Initialise une nouvelle instance de la classe Stack qui est vide et possède une capacité égale à la plus grande valeur parmi la capacité initiale spécifiée et la capacité initiale par défaut.

Propriétés

Count	Obtient le nombre d’éléments contenus dans le Stack.
IsSynchronized	Obtient une valeur indiquant si l’accès à Stack est synchronisé (thread-safe).
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès à Stack.

Méthodes

Clear()	Supprime tous les objets du Stack.
Clone()	Crée une copie superficielle de Stack.
Contains(Object)	Détermine si le Stack contient un élément.
CopyTo(Array, Int32)	Copie Stack dans un tableau Array unidimensionnel existant, en commençant à l'index du tableau spécifié.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetEnumerator()	Retourne IEnumerator pour l'objet Stack.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Peek()	Retourne l'objet situé en haut de Stack sans le supprimer.
Pop()	Supprime et retourne l’objet en haut de Stack.
Push(Object)	Insère un objet en haut de Stack.
Synchronized(Stack)	Retourne un wrapper synchronisé (thread-safe) pour Stack.
ToArray()	Copie Stack vers un nouveau tableau.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

Cohérence de thread

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Pour garantir la sécurité du thread de , Stacktoutes les opérations doivent être effectuées via le wrapper retourné par la Synchronized(Stack) méthode .

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres threads.

Voir aussi

• Stack<T>