Enum enum( ipEnum );
while( enum )
{
    do_sth( enum.get() );
    ++enum;
}

Enum enum( ipArr );
while( enum )
{
    ipUnk = enum.get();
    ....
    ++enum;
}

#if        !defined(__NENUMERATOR_H) || !defined(__NENUMERATOR_H_0F9A6763_0891_4710_9DE2_2E7915D7741C_INCLUDED)
#define    __NENUMERATOR_H_0F9A6763_0891_4710_9DE2_2E7915D7741C_INCLUDED
#define    __NENUMERATOR_H    "{0F9A6763-0891-4710-9DE2-2E7915D7741C}"

namespace Abacl
{

    //===============================================================================================
    // Name: 
    //    
    //    template<T> struct IEnumerable;
    //    
    // Purpose: 
    //    
    //    作为可枚举（可遍历）对象的接口定义。
    //    
    //-----------------------------------------------------------------------------------------------

    template<typename T>
    struct IEnumerable
    {
        
        //=======================================================================================
        // Name: 
        //    
        //    typedef ValueType;
        //    
        // Purpose: 
        //    
        //    遍历的目标元素类型。
        //    
        //---------------------------------------------------------------------------------------
        
        typedef T ValueType;

        // 
        // 虚析构函数
        // 
        
        virtual ~IEnumerable()
        {
        }

        //=======================================================================================
        // Name: 
        //    
        //    ValueType & Current();
        //    
        // Purpose: 
        //    
        //    返回当前遍历的目标元素
        //    
        // Returns: 
        //    
        //    返回当前遍历的目标元素引用。
        //    
        // Remarks: 
        //    
        //    该函数不是 const 成员函数，因此在实现此函数时可能需要进行转型。
        //    
        //---------------------------------------------------------------------------------------
        
        virtual ValueType & Current() = 0;
        
        //=======================================================================================
        // Name: 
        //    
        //    bool IsValid();
        //    
        // Purpose: 
        //    
        //    判断当前遍历位置是否有效。
        //    
        // Returns: 
        //    
        //    返回 true 表明当前遍历位置有效，可以调用 Current，否则表明位置无效，不能调用 Current。
        //    
        //---------------------------------------------------------------------------------------
        
        virtual bool IsValid() const = 0;
        
        //=======================================================================================
        // Name: 
        //    
        //    bool MoveNext();
        //    
        // Purpose: 
        //    
        //    移动到下一个遍历位置。
        //    
        // Returns: 
        //    
        //    返回 true 表明当前遍历位置有效，可以调用 Current，否则表明位置无效，不能调用 Current。
        //    
        //---------------------------------------------------------------------------------------
        
        virtual bool MoveNext() = 0;
        
        //=======================================================================================
        // Name: 
        //    
        //    bool Reset();
        //    
        // Purpose: 
        //    
        //    将当前遍历位置恢复为起始位置。
        //    
        // Returns: 
        //    
        //    返回 true 表明当前遍历位置有效，可以调用 Current，否则表明位置无效，不能调用 Current。
        //    
        // Remarks: 
        //    
        //    对于某些对象，该操作可能不能进行。
        //    
        //---------------------------------------------------------------------------------------
        
        virtual bool Reset() = 0;
    };

    //===============================================================================================
    // Name: 
    //    
    //    template<typename T> class DefaultEnumeratorProxy;
    //    
    // Purpose: 
    //    
    //    代理未实现 IEnumerable 接口的对象。实现 IEnumerable 接口的对象可以应用 foreach 和 foreach_n
    //    宏来实现遍历。
    //    
    // Template Parameters: 
    //    
    //    T            需要代理的源对象
    //    
    // Remarks: 
    //    
    //    通过类特化和偏特化，实现了下列对象的代理：
    //
    //    STL 容器    所有 STL 容器均可以通过 DefaultEnumeratorProxy 代理
    //    数组        所有对象的数组均可以通过 DefaultEnumeratorProxy 代理，但是必须能获取数组元
    //                素数，亦即，不能是 T a[] 形式的数组，而必须是 T a[N] 形式的数组
    //    指针        所有对象的指针均可以通过 DefaultEnumeratorProxy 代理，但是 foreach 只能正确迭代
    //                字符指针，因为如果不指定元素大小，DefaultEnumeratorProxy 只能通过检查元素值
    //                是否为 0 来判断是否迭代结束。对于任意类型的对象指针，应当使用 foreach_n
    //                遍历。
    //    
    //    对于未支持的类型，将会出现编译错误。
    //
    //-----------------------------------------------------------------------------------------------

    // 
    // 泛化版本，用于所有 STL 容器（或者支持 STL 容器接口的类型）
    // 

    template<typename containerT>
    class DefaultEnumeratorProxy: 
        public IEnumerable<typename IsTypeConst<typename containerT::value_type>::NonConstType>
    {
        typedef containerT ContainerType;
        typedef typename IfThenElse<IsTypeConst<ContainerType>::Yes, typename ContainerType::const_iterator, typename ContainerType::iterator>::ResultType IteratorType;
        typedef typename IsTypeConst<typename containerT::value_type>::NonConstType ValueType;

    private:
        mutable ContainerType & mContainer;
        IteratorType mIterator;

    private:
        DefaultEnumeratorProxy();
        DefaultEnumeratorProxy(const DefaultEnumeratorProxy & rhs);
        DefaultEnumeratorProxy & operator = (const DefaultEnumeratorProxy & rhs);

    public:
        DefaultEnumeratorProxy(ContainerType & container)
            : mContainer(container),
              mIterator(container.begin())
        {
        }

        virtual ValueType & Current()
        {
            return const_cast<ValueType &>(*mIterator);
        }

        virtual bool IsValid() const
        {
            return mIterator != mContainer.end();
        }

        virtual bool MoveNext()
        {
            if (IsValid())
            {
                ++mIterator;
            }

            return IsValid();
        }

        virtual bool Reset()
        {
            mIterator = mContainer.begin();

            return IsValid();
        }
    };

    // 
    // 对指针的特化版本
    // 

    template<typename T>
    class DefaultEnumeratorProxy<T *>: 
        public IEnumerable<typename IsTypeConst<T>::NonConstType>
    {
        typedef T * ContainerType;
        typedef SizeType IteratorType;
        typedef typename IsTypeConst<T>::NonConstType ValueType;

    private:
        ContainerType mContainer;
        IteratorType mIterator;
        const SizeType mCount;

    private:
        DefaultEnumeratorProxy();
        DefaultEnumeratorProxy(const DefaultEnumeratorProxy & rhs);
        DefaultEnumeratorProxy & operator = (const DefaultEnumeratorProxy & rhs);

    public:
        DefaultEnumeratorProxy(ContainerType container, SizeType count = 0)
            : mContainer(container),
              mIterator(0),
              mCount(count)
        {
        }

        virtual ValueType & Current()
        {
            return const_cast<ValueType &>(mContainer[mIterator]);
        }

        virtual bool IsValid() const
        {
            if (mCount == 0)
            {
                return mContainer[mIterator] != ValueType();
            }
            else
            {
                return mIterator < mCount;
            }
        }

        virtual bool MoveNext()
        {
            if (IsValid())
            {
                ++mIterator;
            }

            return IsValid();
        }

        virtual bool Reset()
        {
            mIterator = 0;
            
            return IsValid();
        }
    };

    // 
    // 对数组的特化版本。
    // 注：形如 T a[] 形式的数组被认为是指针。
    // 

    template<typename T, size_t N>
    class DefaultEnumeratorProxy<T [N]>: 
        public CustomizedNewObject<AbaclFastAllocator>,
        public IEnumerable<typename IsTypeConst<T>::NonConstType>
    {
        typedef T ContainerType[N];
        typedef size_t IteratorType;
        typedef typename IsTypeConst<T>::NonConstType ValueType;

    private:
        ContainerType&  mContainer;
        IteratorType mIterator;

    private:
        DefaultEnumeratorProxy();
        DefaultEnumeratorProxy(const DefaultEnumeratorProxy & rhs);
        DefaultEnumeratorProxy & operator = (const DefaultEnumeratorProxy & rhs);

    public:
        DefaultEnumeratorProxy(ContainerType & container)
            : mContainer(container),
              mIterator(0)
        {
        }

        virtual ValueType & Current()
        {
            return mContainer[mIterator];
        }

        virtual bool IsValid() const
        {
            return mIterator < N;
        }

        virtual bool MoveNext()
        {
            if (IsValid())
            {
                ++mIterator;
            }

            return IsValid();
        }

        virtual bool Reset()
        {
            mIterator = 0;
            
            return IsValid();
        }
    };

    //===========================================================================================
    // Name: 
    //    
    //    template<U, T, bool NeedProxy> struct ForEachCreateEnumerator;
    //    
    // Purpose: 
    //    
    //    如果类型 U 没有实现 IEnumerable 接口，则创建创建代理对象，否则仅返回 IEnumerable
    //
    // Template Parameters
    //
    //    U            容器对象，可以是实现了 IEnumerable 接口，也可以没有实现。如果没有实现
    //                则会创建一个代理对象。
    //    T            遍历对象的元素类型
    //    NeedProxy    非类型参数，如果为 true，表明 U 没有实现 IEnumerable 接口，需要代理，
    //                否则就不需要代理
    //
    //    Remarks:
    //
    //        调用 Create 函数创建。
    //
    //-------------------------------------------------------------------------------------------
    
    template<typename U, typename T, bool NeedProxy = IsTypeDerivedFrom<U, IEnumerable<T> >::Yes != 0>
    struct ForEachCreateEnumerator;

    template<typename U, typename T>
    struct ForEachCreateEnumerator<U, T, true>
    {
        static IEnumerable<T> * Create(IEnumerable<T> & enumerator)
        {
            return &enumerator;
        }

        static IEnumerable<T> * Create(IEnumerable<T> & enumerator, SizeType /*count*/)
        {
            return &enumerator;
        }
    };

    template<typename U, typename T>
    struct ForEachCreateEnumerator<U, T, false>
    {
        static IEnumerable<T> * Create(U & enumerator)
        {
            return new DefaultEnumeratorProxy<U>(enumerator);
        }

        static IEnumerable<T> * Create(U & enumerator, SizeType count)
        {
            return new DefaultEnumeratorProxy<U>(enumerator, count);
        }
    };

    //===========================================================================================
    // Name: 
    //    
    //    template<typename T> class ForEachEnumerator;
    //    
    // Purpose: 
    //    
    //    用于 foreach 和 foreach_n 的枚举代理。
    //    
    //-------------------------------------------------------------------------------------------
    
    template<typename T>
    class ForEachEnumerator
    {
    private:
        bool mOwn;
        IEnumerable<T> * mEnumerator;

    public:
        template<typename U>
        explicit ForEachEnumerator(U & enumerator)
            : mOwn(IsTypeDerivedFrom<U, IEnumerable<T> >::No != 0),
              mEnumerator(ForEachCreateEnumerator<U, T>::Create(enumerator))
        {
        }

        template<typename U>
        explicit ForEachEnumerator(U & enumerator, SizeType count)
            : mOwn(IsTypeDerivedFrom<U, IEnumerable<T> >::No != 0),
              mEnumerator(ForEachCreateEnumerator<U, T>::Create(enumerator, count))
        {
        }

        ~ForEachEnumerator()
        {
            if (mOwn)
            {
                delete mEnumerator;
            }
        }

        operator T & ()
        {
            return mEnumerator->Current();
        }

        bool IsValid() const
        {
            return mEnumerator->IsValid();
        }

        bool MoveNext()
        {
            return mEnumerator->MoveNext();
        }
    };

    //===============================================================================================
    // Name: 
    //    
    //    foreach(value_type, iterator, container)
    //    foreach_n(value_type, iterator, container, n)
    //    
    // Purpose: 
    //    
    //    对实现 IEnumerable 接口的对象进行遍历，对于部分未实现 IEnumerable 接口的类型进行包装后
    //    遍历。
    //
    //    对于非字符类型的指针，使用 foreach_n 遍历。
    //    
    // Parameters:
    //
    //    value_type        遍历的元素类型
    //    iterator        遍历的迭代器名称
    //    container        遍历的容器名称
    //    n                对于指针类型，遍历的元素个数
    //
    //-----------------------------------------------------------------------------------------------

#define foreach(value_type, iterator, container) \
    for (Abacl::ForEachEnumerator<value_type> iterator(container); iterator.IsValid(); iterator.MoveNext())

#define foreach_n(value_type, iterator, container, n) \
    for (Abacl::ForEachEnumerator<value_type> iterator(container, n); iterator.IsValid(); iterator.MoveNext())

}

#endif    // if !defined(__NENUMERATOR_H_0F9A6763_0891_4710_9DE2_2E7915D7741C_INCLUDED)