Stack Stack Stack Stack Class

Definicja

Reprezentuje prostą nieogólną kolekcję obiektów w pierwszej kolejności (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
Dziedziczenie
StackStackStackStack
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak utworzyć i dodać wartości do stosu oraz jak wyświetlić jego wartości.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

Uwagi

Pojemność Stack to liczba elementów, które mogą być przechowywane w Stack.The capacity of a Stack is the number of elements the Stack can hold. Po dodaniu elementów do Stack pojemność jest automatycznie zwiększana zgodnie z wymaganiami ponownej alokacji.As elements are added to a Stack, the capacity is automatically increased as required through reallocation.

Ważne

Nie zalecamy używania klasy Stack w celu tworzenia nowych rozwiązań.We don't recommend that you use the Stack class for new development. Zamiast tego zaleca się użycie klasy generycznej System.Collections.Generic.Stack<T>.Instead, we recommend that you use the generic System.Collections.Generic.Stack<T> class. Aby uzyskać więcej informacji, zobacz kolekcje nieogólne nie mogą być używane w serwisie GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Jeśli wartość Count jest mniejsza niż pojemność stosu, Push jest operacją O(1).If Count is less than the capacity of the stack, Push is an O(1) operation. Jeśli pojemność musi zostać zwiększona w celu uwzględnienia nowego elementu, Push będzie operacją O(n), gdzie n jest Count.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Pop jest operacją O(1).Pop is an O(1) operation.

Stack akceptuje null jako prawidłową wartość i umożliwia duplikowanie elementów.Stack accepts null as a valid value and allows duplicate elements.

Konstruktory

Stack() Stack() Stack() Stack()

Inicjuje nowe wystąpienie klasy Stack, która jest pusta i ma domyślną pojemność początkową.Initializes a new instance of the Stack class that is empty and has the default initial capacity.

Stack(ICollection) Stack(ICollection) Stack(ICollection) Stack(ICollection)

Inicjuje nowe wystąpienie klasy Stack zawierające elementy skopiowane z określonej kolekcji i ma taką samą pojemność początkową jak liczba skopiowanych elementów.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) Stack(Int32) Stack(Int32) Stack(Int32)

Inicjuje nowe wystąpienie klasy Stack, która jest pusta i ma określoną pojemność początkową lub domyślną pojemność początkową, w zależności od tego, która wartość jest większa.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.

Właściwości

Count Count Count Count

Pobiera liczbę elementów zawartych w Stack.Gets the number of elements contained in the Stack.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Pobiera wartość wskazującą, czy dostęp do Stack jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the Stack is synchronized (thread safe).

SyncRoot SyncRoot SyncRoot SyncRoot

Pobiera obiekt, którego można użyć do synchronizowania dostępu do Stack.Gets an object that can be used to synchronize access to the Stack.

Metody

Clear() Clear() Clear() Clear()

Usuwa wszystkie obiekty z Stack.Removes all objects from the Stack.

Clone() Clone() Clone() Clone()

Tworzy skróconą kopię Stack.Creates a shallow copy of the Stack.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Określa, czy element znajduje się w Stack.Determines whether an element is in the Stack.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Kopiuje Stack do istniejącej jednowymiarowej Array, rozpoczynając od określonego indeksu tablicy.Copies the Stack to an existing one-dimensional Array, starting at the specified array index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Zwraca IEnumerator dla Stack.Returns an IEnumerator for the Stack.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Inherited from Object)
Peek() Peek() Peek() Peek()

Zwraca obiekt w górnej części Stack bez usuwania go.Returns the object at the top of the Stack without removing it.

Pop() Pop() Pop() Pop()

Usuwa i zwraca obiekt w górnej części Stack.Removes and returns the object at the top of the Stack.

Push(Object) Push(Object) Push(Object) Push(Object)

Wstawia obiekt w górnej części Stack.Inserts an object at the top of the Stack.

Synchronized(Stack) Synchronized(Stack) Synchronized(Stack) Synchronized(Stack)

Zwraca zsynchronizowaną otokę (bezpieczne wątki) dla Stack.Returns a synchronized (thread safe) wrapper for the Stack.

ToArray() ToArray() ToArray() ToArray()

Kopiuje Stack do nowej tablicy.Copies the Stack to a new array.

ToString() ToString() ToString() ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Inherited from Object)

Metody rozszerzania

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable elementu do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Dotyczy

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) składowe tego typu są bezpieczne dla wątków.Public static (Shared in Visual Basic) members of this type are thread safe. Wystąpienia elementów członkowskich nie dają gwarancji bezpieczeństwa wątków.Any instance members are not guaranteed to be thread safe.

Aby zagwarantować bezpieczeństwo wątku Stack, wszystkie operacje muszą być wykonywane przez otokę zwróconą przez metodę Synchronized(Stack).To guarantee the thread safety of the Stack, all operations must be done through the wrapper returned by the Synchronized(Stack) method.

Wyliczanie w kolekcji nie jest wewnętrznie procedurą odporną na wielowątkowość.Enumerating through a collection is intrinsically not a thread-safe procedure. Nawet gdy kolekcja jest synchronizowana, inne wątki nadal mogą ją modyfikować. Powoduje to zgłaszanie wyjątku przez moduł wyliczający.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, można zablokować kolekcję podczas całego procesu wyliczania albo rejestrować wyjątki wynikłe ze zmian wprowadzanych przez inne wątków.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.

Zobacz też