Il costruttore Stack <> effettua lo storno dello stack quando viene inizializzato da un altro?

Question

ecco il codice:

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

e poi vediamo il risultato

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

produce il seguente output:

s stack:4,3,2,1, 

ns stack:1,2,3,4, 

nss stack:4,3,2,1, 

Quindi, ns stack viene ripristinato s stack e nss pila è lo stesso dello stack s.

Answer 1

Il costruttore stack che prende uno IEnumerable<T> inserisce gli elementi come se Add fossero chiamati più volte.

Iterare su uno stack itera in ordine "pop" ... così quando si costruisce uno stack da un altro, si aggiungerà prima la parte superiore dello stack originale, quindi si posizionerà l'elemento "secondo dall'alto" sopra che nel nuovo stack, ecc., in modo efficace, invertendolo.

Answer 2

Il costruttore che si sta utilizzando per ns e nss è Stack<T>(IEnumerable<T>). Quando si enumera uno stack enumera da cima a fondo. Ma quando crea una pila, spinge gli elementi in ordine enumerato. Quindi l'ultimo elemento enumerato (ultimo nell'origine) sarà in cima al nuovo stack.

Quindi sì, inverte l'ordine degli elementi.

Answer 3

L'indizio per la tua sorpresa è nella vostra domanda:

fa Stack <> costruttore invertire lo stack quando viene inizializzato da altro?

Il ctor si fa riferimento a fa non accettare un altro Stack - piuttosto, accetta un IEnumerable. Cioè, non esiste un trattamento speciale per la costruzione di un Stack da un Stack, rispetto alla costruzione di un Stack da qualsiasi altro IEnumerable.

Quindi, quando si provi e costruire un Stack da un Stack, la fonte Stack viene consumato nel suo ordine di enumerazione naturale, cioè nel popping ordine. E il nuovo Stack è costruito da premendo gli articoli del numero IEnumerable in arrivo. Da qui il comportamento che stai vedendo.