Does Stack<> constructor reverse the stack when being initialized from other one?

Question

Here is the 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));

and then let's see the result

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

produces the following output:

s stack:4,3,2,1,

ns stack:1,2,3,4,

nss stack:4,3,2,1,

So, ns stack is reverted s stack and nss stack is the same as s stack.

Answer 1

The stack constructor which takes an IEnumerable<T> pushes the items on as if Add were called multiple times.

Iterating over a stack iterates in "pop" order... so when you construct one stack from another, it will add the top of the original stack first, then put the "second from the top" element on top of that in the new stack, etc... effectively reversing it.

Answer 2

The constructor you are using for ns an nss is Stack<T>(IEnumerable<T>). When you enumerate a stack it enumerates from top to bottom. But when creating a stack it pushes the elements in enumerated order. So the last enumerated item (last in the source) will be top of the new stack.

So yes, it does reverse the order of elements.

Answer 3

The clue to your surprise is in your question:

Does Stack<> constructor reverse the stack when being initialized from other one ?

The ctor you are referring to does not accept another Stack - rather, it accepts an IEnumerable. That is, there is no special treatment for constructing a Stack from a Stack, as compared to constructing a Stack from any other IEnumerable.

So when you do try and construct a Stack from a Stack, the source Stack is consumed in its natural enumeration order, ie in the popping order. And the new Stack is constructed by pushing the items of the incoming IEnumerable. Hence the behaviour you are seeing.