Versetzt Stack <> Konstruktor den Stapel, wenn er von einem anderen initialisiert wird?

Question

Hier ist der Code:

var s = new Stack<int>(); 
s.Push(1); 
s.Push(2); 
s.Push(3); 
s.Push(4); 

var ns = new Stack<int>(s); 
var nss = new Stack<int>(new Stack<int>(s)); 

und dann lass uns

 tbLog.Text += "s stack:"; 
     while(s.Count > 0) 
     { 
      tbLog.Text += s.Pop() + ","; 
     } 
     tbLog.Text += Environment.NewLine; 
     tbLog.Text += "ns stack:"; 
     while (ns.Count > 0) 
     { 
      tbLog.Text += ns.Pop() + ","; 
     } 

     tbLog.Text += Environment.NewLine; 
     tbLog.Text += "nss stack:"; 
     while (nss.Count > 0) 
     { 
      tbLog.Text += nss.Pop() + ","; 
     } 

erzeugt die folgende Ausgabe sehen das Ergebnis:

s stack:4,3,2,1, 

ns stack:1,2,3,4, 

nss stack:4,3,2,1, 

So wird ns Stapel zurück s Stapel und nss Stapel ist das gleiche wie s Stapel.

Answer 1

Der Stack-Konstruktor, der eine IEnumerable<T> nimmt, schiebt die Elemente an, als wenn Add mehrere Male aufgerufen wurden.

Iterieren über einen Stapel iteriert in "Pop" -Reihenfolge ... Wenn Sie also einen Stapel aus einem anderen Stapel erstellen, fügt er zuerst den Anfang des ursprünglichen Stapels und dann das Element "zweit von oben" hinzu das im neuen Stapel, usw. ... es effektiv umkehrt.

Answer 2

Der Konstruktor, den Sie für ns und nss verwenden, ist Stack<T>(IEnumerable<T>). Wenn Sie einen Stapel aufzählen, zählt er von oben nach unten auf. Beim Erstellen eines Stapels werden die Elemente jedoch in Aufzählungsreihenfolge verschoben. Das letzte aufgezählte Element (das letzte in der Quelle) wird also oben auf dem neuen Stapel stehen.

Also ja, es ändert die Reihenfolge der Elemente.

Answer 3

Der Schlüssel zu Ihrer Überraschung ist in Ihrer Frage:

stackt <> Konstruktor den Stapel umgekehrt, wenn sie von anderen initialisiert werden?

Die Ctor Sie sich beziehen tut nicht akzeptieren andere Stack - besser gesagt, es nimmt eine IEnumerable. Das heißt, es gibt keine spezielle Behandlung zum Konstruieren einer Stack aus einer Stack, im Vergleich zum Konstruieren einer Stack aus einer anderen IEnumerable.

Also, wenn Sie versuchen und bauen eine Stack von einem Stack, die Quelle Stack wird in seiner natürlichen Aufzählung Ordnung, dh in der popping verbraucht, um. Und die neue Stack wird von der Elemente der eingehenden IEnumerable gebaut. Daher das Verhalten, das Sie sehen.