STL stack allocate

游戏编程精粹3提供了一份栈分配器源代码：

#include <memory>
#include <limits>

template <typename T>
class StackAlloc
{
public:

    // Typedefs
    typedef size_t    size_type;
    typedef ptrdiff_t difference_type;
    typedef T*        pointer;
    typedef const T*  const_pointer;
    typedef T&        reference;
    typedef const T&  const_reference;
    typedef T         value_type;

    // Constructors
    StackAlloc() throw()
    :
        mpStack( NULL ),
        mBytesAllocated( 0 ),
        mMaxBytes( 0 )
    {
    }

    StackAlloc( unsigned char* pStack, size_t nMaxBytes ) throw()
    :
        mpStack( pStack ),
        mBytesAllocated( 0 ),
        mMaxBytes( nMaxBytes )
    {
    }

    StackAlloc( const StackAlloc& sa ) throw()
    :
        mpStack( sa.mpStack ),
        mBytesAllocated( 0 ),
        mMaxBytes( sa.mMaxBytes )
    {
        // Copying the "stack" resets mBytesAllocated to zero
    }

#if _MSC_VER >= 1400 // VC 7 can't handle template members
    template <typename U>
    StackAlloc( const StackAlloc<U>& sa ) throw()
    :
        mpStack( sa.mpStack ),
        mBytesAllocated( 0 ),
        mMaxBytes( sa.mMaxBytes )
    {
        // Copying the "stack" resets mBytesAllocated to zero
    }
#endif

    StackAlloc& operator=( const StackAlloc& sa )
    {
        // Copying the "stack" resets mBytesAllocated to zero
        mpStack = sa.mpStack;
        mBytesAllocated = 0;
        mMaxBytes = sa.mMaxBytes;
        return *this;
    }

    // Destructor
    ~StackAlloc() throw()
    {
    }

    // Utility functions
    pointer address( reference r ) const
    {
        return &r;
    }

    const_pointer address( const_reference c ) const
    {
        return &c;
    }

    size_type max_size() const
    {
        return std::numeric_limits<size_t>::max() / sizeof(T);
    }

    // In-place construction
    void construct( pointer p, const_reference c )
    {
        // placement new operator
        new( reinterpret_cast<void*>(p) ) T(c);
    }

    // In-place destruction
    void destroy( pointer p )
    {
        // call destructor directly
        (p)->~T();
    }

    // Rebind to allocators of other types
    template <typename U>
    struct rebind
    {
        typedef StackAlloc<U> other;
    };

    // Allocate raw memory
    pointer allocate( size_type n, const void* = NULL )
    {
        void* pRaw = mpStack + mBytesAllocated;
        mBytesAllocated += ( n * sizeof(T) );

        if( mBytesAllocated+1 > mMaxBytes )
            throw std::bad_alloc();

        return pointer(pRaw);
    }

    // Free raw memory.
    // Note that C++ standard defines this function as
    // deallocate( pointer p, size_type). Because Visual C++ 6.0
    // compiler doesn't support template rebind, Dinkumware uses
    // void* hack.
    void deallocate( void*, size_type )
    {
        // No need to free stack memory
    }

    // Non-standard Dinkumware hack for Visual C++ 6.0 compiler.
    // VC 6 doesn't support template rebind.
    char* _Charalloc( size_type n )
    {
        return reinterpret_cast<char*>( allocate( n, NULL ) );
    }

    // Required for global comparison functions
    unsigned char* GetStack() const
    {
        return mpStack;
    }

private:

    unsigned char* mpStack;
    size_t         mBytesAllocated;
    size_t         mMaxBytes;

}; // end of StackAlloc

// Comparison
template <typename T1>
bool operator==( const StackAlloc<T1>& lhs, const StackAlloc<T1>& rhs) throw()
{
    return lhs.GetStack() == rhs.GetStack();
}

template <typename T1>
bool operator!=( const StackAlloc<T1>& lhs, const StackAlloc<T1>& rhs) throw()
{
    return lhs.GetStack() != rhs.GetStack();
}

测试发现在VS2012下编译运行，栈分配器在释放内存时出错。

原因是当用户提供自定义的分配器时，VS会保存一个分配策略对象来管理计数神马的。
部分VS源代码如下：

    _Vector_alloc(const _Alty& _Al = _Alty())
        : _Alval(_Al)
        {    // construct allocator from _Al
        _Alloc_proxy();
        }
//-------------------------------------------------------------
    void _Alloc_proxy()
        {    // construct proxy from _Alval
        typename _Alloc::template rebind<_Container_proxy>::other
            _Alproxy(_Alval);
        this->_Myproxy = _Alproxy.allocate(1);
        _Alproxy.construct(this->_Myproxy, _Container_proxy());
        this->_Myproxy->_Mycont = this;
        }

vector的栈分配器是_Alval，也就是用户提供的栈分配器。

分配策略对象_Myproxy占用的内存也是通过_Alval申请的。仅仅是这样也许不会出现神马问题，可是_Myproxy是通过调用template <typename U> StackAlloc( const StackAlloc<U>& sa )重绑定函数从_Alval获取了一个新的分配器对象_Alproxy。此时_Alval与_Alproxy其实是共用一段内存的，而彼此不知道对方的存在。导致_Myproxy使用的内存在vector插入元素时被覆盖。当vector释放内存或者迁移内存时需要释放掉_Myproxy的内存时程序就崩溃了。

实际上游戏编程精粹3提供的stack allocate在语义上就存在问题，mpstack不应该是值语义的，因为stack allocate实际上即没有真正向系统申请内存，也并没有真正的释放内存，而只是代为管理一段原本就存在的内存。因此，mpstack应该是引用语义的。

现将本人修改后的代码献上：

PS:只在VS2012下测试了vector与list容器。

        template<typename T>
        class stack_alloc
        {
        public:
            typedef size_t    size_type;
            typedef ptrdiff_t difference_type;
            typedef T*        pointer;
            typedef const T*  const_pointer;
            typedef T&        reference;
            typedef const T&  const_reference;
            typedef T         value_type;

        public:
            stack_alloc() throw()
                : m_begin(NULL)
                , m_cur(m_begin)
                , m_max_bytes(0)
            {
            }

            stack_alloc(uchar* pstack, size_t max_bytes) throw()
                : m_begin(pstack)
                , m_cur(m_begin)
                , m_max_bytes(max_bytes)
            {
            }

            stack_alloc(const stack_alloc& sa) throw()
                : m_begin(sa.m_begin)
                , m_cur(sa.m_cur)
                , m_max_bytes(sa.m_max_bytes)
            {
            }

#if _MSC_VER >= 1400 // VC 7 can't handle template members
            template <typename U>
            stack_alloc(const stack_alloc<U>& sa) throw()
                : m_begin(sa.m_begin)
                , m_cur(sa.m_cur)
                , m_max_bytes(sa.m_max_bytes)
            {
            }
#endif

            stack_alloc& operator=( const stack_alloc& rhs )
            {
                return *this;
            }

            ~stack_alloc() throw()
            {
            }

        public:
            // Utility functions
            pointer address( reference r ) const
            {
                return &r;
            }

            const_pointer address( const_reference c ) const
            {
                return &c;
            }

            size_type max_size() const
            {
                return m_max_bytes/sizeof(T);
            }

            // In-place construction
            void construct( pointer p, const_reference c )
            {
                new( reinterpret_cast<void*>(p) ) T(c);
            }

            // In-place destruction
            void destroy( pointer p )
            {
                (p)->~T();
            }

            // Rebind to allocators of other types
            template <typename U>
            struct rebind
            {
                typedef stack_alloc<U> other;
            };

            // Allocate raw memory
            pointer allocate( size_type n, const void* = NULL )
            {
                void* praw = m_cur;
                m_cur += n*sizeof(T);
                if(m_cur+1>m_begin+m_max_bytes)
                {
                    throw std::bad_alloc();
                }

                return pointer(praw);
            }

            void deallocate( void* p, size_type n)
            {                
            }

            // Non-standard Dinkumware hack for Visual C++ 6.0 compiler.
            // VC 6 doesn't support template rebind.
            char* _charalloc( size_type n )
            {
                return reinterpret_cast<char*>( allocate( n, NULL ) );
            }

            unsigned char* get_stack() const
            {
                return m_begin;
            }

            uchar*&            m_cur;
            size_t            m_max_bytes;
            uchar*            m_begin;
        };

        template <typename T>
        bool operator==( const stack_alloc<T>& lhs, const stack_alloc<T>& rhs) throw()
        {
            return lhs.get_stack() == rhs.get_stack();
        }

        template <typename T>
        bool operator!=( const stack_alloc<T>& lhs, const stack_alloc<T>& rhs) throw()
        {
            return lhs.get_stack() != rhs.get_stack();
        }