Question

我遇到了这个问题，我一直想弄清楚。我试图使CustomStack像Stack一样，只实现Push（T），Pop（），Peek（）和Clear（）方法。我有这个代码，我认为它是正确的，但输出只显示一半的数字。我认为这与推送方法有关，但我看不出它有什么问题。

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;

namespace Enumerator
{
    class Program
    {
        static void Main(string[] args)
        {
            CustomStack<int> collection = new CustomStack<int>();

            for (int i = 0; i < 30; i++)
            {
                collection.Push(i);
                Console.WriteLine(collection.Peek());
            }
            collection.Push(23);
            foreach (int x in collection)
            {
                Console.WriteLine(collection.Pop());
            }

            Console.WriteLine("current", collection.Peek());
            Console.ReadKey();
        }
    }

    public class CustomStack<T> : IEnumerable<T>
    {

        private T[] arr;
        private int count;

        public CustomStack()
        {
            count = 0;
            arr = new T[5];
        }


        public T Pop()
        {
            int popIndex = count;
            if (count > 0)
            {
                count--;
                return arr[popIndex];
            }
            else
            {
                return arr[count];
            }

        }

        public void Push(T item)
        {

            count++;
            if (count == arr.Length)
            {
                Array.Resize(ref arr, arr.Length + 1);
            }

            arr[count] = item;


        }

        public void Clear()
        {
            count = 0;

        }

        public T Peek()
        {
            return arr[count];
        }

        public int Count
        {
            get
            {
                return count;
            }
        }

        public IEnumerator<T> GetEnumerator()
        {
            return new MyEnumerator(this);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return new MyEnumerator(this);
        }

        public class MyEnumerator : IEnumerator<T>
        {
            private int position;
            private CustomStack<T> stack;

            public MyEnumerator(CustomStack<T> stack)
            {
                this.stack = stack;
                position = -1;
            }
            public void Dispose()
            {

            }
            public void Reset()
            {
                position = -1;
            }

            public bool MoveNext()
            {
                position++;
                return position < stack.Count;
            }

            Object IEnumerator.Current
            {
                get
                {
                    return stack.arr[position];
                }
            }
            public T Current
            {
                get
                {
                    return stack.arr[position];

                }
            }
        }
    }
}

Answer 1

您正在执行从不执行所需的操作：在使用枚举器进行迭代时，您正在修改集合。（foreach循环是用于分配枚举数的语法糖。）

IEnumerable的文档实际上表明，如果您的数据结构在枚举时被修改，那么像您的实现会抛出异常。（尝试使用List<T>，您会看到;如果您在foreach中枚举列表时添加或删除项目，则会抛出该列表。）

这就是你问题的原因;你的数据结构不是设计成（1）在滥用时扔掉，或者（2）在滥用时表现良好，因此当你滥用它时它表现得很糟糕。

我的建议：如果你这样做会伤害，不要这样做。在枚举它的循环中不要修改集合。

相反，创建一个IsEmpty属性并编写循环：

while(!collection.IsEmpty) Console.WriteLine(collection.Pop());

这样，当同时处理枚举器时，您不会修改集合。

您在这里遇到的具体问题是：position每次循环都会增加。并且count总是在减少。你说只有一半的物品被计算在内。好吧，搞定吧。如果你有10个项目，则位置从零开始，并且增加直到它大于计数，然后每次通过循环......

position count 0 10 1 9 2 8 3 7 4 6 5 5

我们已经完成了，我们只列举了一半的项目。

如果您希望在迭代时面对被修改时使您的集合变得健壮，那么 position必须在推送或弹出堆栈时更改。即使计数在变化，也不能盲目地增加每次。制定正确的行为非常棘手，这就是为什么文档建议您只是抛出。

如果你想让你的集合在枚举时修改异常，那么诀窍就是让对象有一个名为“版本号”的int。每次推送或弹出集合时，请更改版本号。然后让迭代器在迭代开始时获取版本号的副本;如果它检测到当前版本号与副本不同，则在枚举期间修改了集合，您可以抛出集合修改的异常。

感谢有趣的问题;我可能会在我的博客中使用它作为一个例子，并且可能看看我是否可以编写一个静态分析器来检测这种危险的修改。

自定义堆栈<t>使用IEnumerable <t>和Array？</t> </t>

1 个答案: