Est-ce que Stack <> constructeur inverser la pile lors de l'initialisation de l'autre?

Question

Voici le 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)); 

puis nous allons voir le résultat

 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() + ","; 
     } 

produit la sortie suivante:

s stack:4,3,2,1, 

ns stack:1,2,3,4, 

nss stack:4,3,2,1, 

Ainsi, ns pile est revenue s pile et nss pile est la même que la pile s.

Answer 1

Le constructeur de pile qui prend un IEnumerable<T> appuie sur les éléments comme si Add étaient appelés plusieurs fois. L'itération sur une pile itère dans l'ordre "pop" ... donc quand vous construisez une pile d'une autre, elle ajoute d'abord le sommet de la pile originale, puis placez l'élément "second from the top" au-dessus de que dans la nouvelle pile, etc ... en l'inversant effectivement.

Answer 2

Le constructeur que vous utilisez pour ns et nss est Stack<T>(IEnumerable<T>). Lorsque vous énumérez une pile, elle énumère de haut en bas. Mais lors de la création d'une pile, elle pousse les éléments dans l'ordre énuméré. Donc, le dernier objet énuméré (dernier dans la source) sera en haut de la nouvelle pile.

Alors oui, cela inverse l'ordre des éléments.

Answer 3

L'indice de votre surprise est dans votre question:

Stack < Est-ce que> constructeur inverser la pile lors de l'initialisation autre?

Le cteur vous faites référence ne pas accepter une autre Stack - plutôt, il accepte un IEnumerable. Autrement dit, il n'y a pas de traitement spécial pour construire un Stack à partir d'un Stack, par rapport à la construction d'un Stack à partir de tout autre IEnumerable.

Alors, quand vous essayez et construire un Stack d'un Stack, la source Stack est consommée dans son ordre d'énumération naturelle, à savoir dans le popping pour. Et le nouveau Stack est construit par en poussant les éléments du IEnumerable entrant. D'où le comportement que vous voyez.