Stack Klasse

Definition

Stellt eine einfache Last-in-First-out-Auflistung (LIFO) von Objekten dar.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
Vererbung
Stack
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie einem Stapel Werte erstellen und Werte hinzufügen und wie die zugehörigen Werte angezeigt werden.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

Hinweise

Die Kapazität einer Stack ist die Anzahl der Elemente, die Stack enthalten kann.The capacity of a Stack is the number of elements the Stack can hold. Beim Hinzufügen von Elementen zu einem Stack wird die Kapazität aufgrund der erneuten Zuordnung automatisch erhöht.As elements are added to a Stack, the capacity is automatically increased as required through reallocation.

Wichtig

Es wird nicht empfohlen, die Stack-Klasse für die neue Entwicklung zu verwenden.We don't recommend that you use the Stack class for new development. Stattdessen wird empfohlen, dass Sie die generische Klasse System.Collections.Generic.Stack<T> verwenden.Instead, we recommend that you use the generic System.Collections.Generic.Stack<T> class. Weitere Informationen finden Sie unter nicht generische Auflistungen sollten nicht auf GitHub verwendet werden.For more information, see Non-generic collections shouldn't be used on GitHub.

Wenn Count kleiner als die Kapazität des Stapels ist, ist Push ein O(1)-Vorgang.If Count is less than the capacity of the stack, Push is an O(1) operation. Wenn die Kapazität für das neue Element erweitert werden muss, wird Push zu einem O(n)-Vorgang, bei dem n Count ist.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Pop ist ein O(1)-Vorgang.Pop is an O(1) operation.

Stack akzeptiert null als gültigen Wert und ermöglicht doppelte Elemente.Stack accepts null as a valid value and allows duplicate elements.

Konstruktoren

Stack()

Initialisiert eine neue, leere Instanz der Stack-Klasse, die die Standardanfangskapazität aufweist.Initializes a new instance of the Stack class that is empty and has the default initial capacity.

Stack(ICollection)

Initialisiert eine neue Instanz der Stack-Klasse, die aus der angegebenen Auflistung kopierte Elemente enthält und deren anfängliche Kapazität der Anzahl der kopierten Elemente entspricht.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)

Initialisiert eine neue, leere Instanz der Stack-Klasse, die über die angegebene anfängliche Kapazität, mindestens aber über die anfängliche Standardkapazität verfügt.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.

Eigenschaften

Count

Ruft die Anzahl der Elemente ab, die in Stack enthalten sind.Gets the number of elements contained in the Stack.

IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Stack synchronisiert (threadsicher) ist.Gets a value indicating whether access to the Stack is synchronized (thread safe).

SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Stack synchronisiert werden kann.Gets an object that can be used to synchronize access to the Stack.

Methoden

Clear()

Entfernt alle Objekte aus dem Stack.Removes all objects from the Stack.

Clone()

Erstellt eine flache Kopie von Stack.Creates a shallow copy of the Stack.

Contains(Object)

Bestimmt, ob sich ein Element in Stack befindet.Determines whether an element is in the Stack.

CopyTo(Array, Int32)

Kopiert Stack in ein vorhandenes eindimensionales Array, beginnend beim angegebenen Arrayindex.Copies the Stack to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetEnumerator()

Gibt einen IEnumerator für das Stack zurück.Returns an IEnumerator for the Stack.

GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
Peek()

Gibt das oberste Objekt von Stack zurück, ohne es zu entfernen.Returns the object at the top of the Stack without removing it.

Pop()

Entfernt das oberste Objekt aus Stack und gibt es zurück.Removes and returns the object at the top of the Stack.

Push(Object)

Fügt ein Objekt am Anfang des Stack ein.Inserts an object at the top of the Stack.

Synchronized(Stack)

Gibt einen synchronisierten (threadsicheren) Wrapper für Stack zurück.Returns a synchronized (thread safe) wrapper for the Stack.

ToArray()

Kopiert Stack in ein neues Array.Copies the Stack to a new array.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)

Erweiterungsmethoden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

Gilt für:

Threadsicherheit

Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind Thread sicher.Public static (Shared in Visual Basic) members of this type are thread safe. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.Any instance members are not guaranteed to be thread safe.

Um die Thread Sicherheit der Stack zu gewährleisten, müssen alle Vorgänge über den von der Synchronized(Stack)-Methode zurückgegebenen Wrapper durchgeführt werden.To guarantee the thread safety of the Stack, all operations must be done through the wrapper returned by the Synchronized(Stack) method.

Die Enumeration einer Auflistung ist systemintern keine threadsichere Prozedur.Enumerating through a collection is intrinsically not a thread-safe procedure. Selbst wenn eine Auflistung synchronisiert wird, besteht die Möglichkeit, dass andere Threads sie ändern. Dies führt dazu, dass der Enumerator eine Ausnahme auslöst.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Um während der Enumeration Threadsicherheit zu gewährleisten, können Sie entweder die Auflistung während der gesamten Enumeration sperren oder die Ausnahmen, die aus von anderen Threads stammenden Änderungen resultieren, abfangen.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.

Siehe auch