Stack Classe

Définition

Représente une simple collection non générique d’objets de type dernier entré, premier sorti (LIFO).Represents a simple last-in-first-out (LIFO) non-generic collection of objects.

public ref class Stack : ICloneable, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Stack : ICloneable, System.Collections.ICollection
type Stack = class
    interface ICollection
    interface ICloneable
    interface IEnumerable
Public Class Stack
Implements ICloneable, ICollection
Héritage
Stack
Attributs
Implémente

Exemples

L’exemple suivant montre comment créer et ajouter des valeurs à une pile et comment afficher ses valeurs.The following example shows how to create and add values to a Stack and how to display its values.

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 correspond au nombre d’éléments que le Stack peut contenir.The capacity of a Stack is the number of elements the Stack can hold. À mesure que des éléments sont ajoutés à un Stack, la capacité est automatiquement augmentée en fonction des besoins par réallocation.As elements are added to a Stack, the capacity is automatically increased as required through reallocation.

Important

Nous vous déconseillons d’utiliser la classe Stack pour le nouveau développement.We don't recommend that you use the Stack class for new development. Au lieu de cela, nous vous recommandons d’utiliser la classe générique System.Collections.Generic.Stack<T>.Instead, we recommend that you use the generic System.Collections.Generic.Stack<T> class. Pour plus d’informations, consultez collections non génériques ne doit pas être utilisé sur GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Si Count est inférieur à la capacité de la pile, Push est une opération O(1).If Count is less than the capacity of the stack, Push is an O(1) operation. Si la capacité doit être augmentée pour s’adapter au nouvel élément, Push devient une opération O(n), où n est Count.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Pop est une opération O(1).Pop is an O(1) operation.

Stack accepte null comme valeur valide et autorise les éléments en double.Stack accepts null as a valid value and allows duplicate elements.

Constructeurs

Stack()

Initialise une nouvelle instance de la classe Stack qui est vide et possède la capacité initiale par défaut.Initializes a new instance of the Stack class that is empty and has the default initial capacity.

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.Initializes a new instance of the Stack class that contains elements copied from the specified collection and has the same initial capacity as the number of elements copied.

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.Initializes a new instance of the Stack class that is empty and has the specified initial capacity or the default initial capacity, whichever is greater.

Propriétés

Count

Obtient le nombre d'éléments contenus dans le Stack.Gets the number of elements contained in the Stack.

IsSynchronized

Obtient une valeur indiquant si l'accès à Stack est synchronisé (thread-safe).Gets a value indicating whether access to the Stack is synchronized (thread safe).

SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à Stack.Gets an object that can be used to synchronize access to the Stack.

Méthodes

Clear()

Supprime tous les objets du Stack.Removes all objects from the Stack.

Clone()

Crée une copie superficielle de Stack.Creates a shallow copy of the Stack.

Contains(Object)

Détermine si le Stack contient un élément.Determines whether an element is in the Stack.

CopyTo(Array, Int32)

Copie Stack dans un Array unidimensionnel existant commençant à l'index de tableau spécifié.Copies the Stack to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetEnumerator()

Retourne un IEnumerator pour Stack.Returns an IEnumerator for the Stack.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Peek()

Retourne l'objet situé en haut de Stack sans le supprimer.Returns the object at the top of the Stack without removing it.

Pop()

Supprime et retourne l'objet en haut de Stack.Removes and returns the object at the top of the Stack.

Push(Object)

Insère un objet en haut de Stack.Inserts an object at the top of the Stack.

Synchronized(Stack)

Retourne un wrapper synchronisé (thread-safe) pour Stack.Returns a synchronized (thread safe) wrapper for the Stack.

ToArray()

Copie Stack vers un nouveau tableau.Copies the Stack to a new array.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(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é.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Cohérence de thread

Public static (Shared dans Visual Basic) les membres de ce type sont thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Il n'est pas garanti que les membres d'instance soient thread-safe.Any instance members are not guaranteed to be thread safe.

Pour garantir la sécurité des threads du Stack, toutes les opérations doivent être effectuées par le biais du wrapper retourné par la méthode Synchronized(Stack).To guarantee the thread safety of the Stack, all operations must be done through the wrapper returned by the Synchronized(Stack) method.

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. 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.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Voir aussi