STL源码剖析在VS2010下运行出错

我试着写一下书上的第一个例子。
在VC2010下运行报错

1>d:\program files\microsoft visual studio 10.0\vc\include\vector(454): error C2440: 'initializing' : cannot convert from 'SimpleAlloc::allocator<T>' to 'SimpleAlloc::allocator<T>'

1>          with

1>          [

1>              T=int

1>          ]

1>          and

1>          [

1>              T=std::_Container_proxy

1>          ]

1>          No constructor could take the source type, or constructor overload resolution was ambiguous

1>          d:\program files\microsoft visual studio 10.0\vc\include\vector(452) : while compiling class template member function 'std::_Vector_val<_Ty,_Alloc>::~_Vector_val(void)'

1>          with

1>          [

1>              _Ty=int,

1>              _Alloc=SimpleAlloc::allocator<int>

1>          ]

1>          d:\program files\microsoft visual studio 10.0\vc\include\vector(481) : see reference to class template instantiation 'std::_Vector_val<_Ty,_Alloc>' being compiled

1>          with

1>          [

1>              _Ty=int,

1>              _Alloc=SimpleAlloc::allocator<int>

1>          ]

1>          e:\programproject\vc2010\stl_sources\stl_sources\2_1_1_simplealloc.h(108) : see reference to class template instantiation 'std::vector<_Ty,_Ax>' being compiled

1>          with

1>          [

1>              _Ty=int,

1>              _Ax=SimpleAlloc::allocator<int>

1>          ]

后来直接复制到VC6.0下运行，正常。
以下是书中代码

#pragma once



#include <new>			//for placement new

#include <cstddef>		//for ptrdiff_t, size_T

#include <cstdlib>		//for exit()

#include <climits>		//for UINT_MAX

#include <iostream>		//for cerr

#include <vector>



using namespace std;



namespace SimpleAlloc

{

	template<class T>

	inline T* _allocate(ptrdiff_t size, T*)

	{

		set_new_handler(0);

		T* tmp = (T*)(::operator new( (size_t)(size * sizeof(T) ) ) );

		if(tmp == 0)

		{

			cerr<<"out of memory"<<endl;

			exit(1);

		}



		return tmp;

	}



	template<class T>

	inline void _deallocate(T* buffer)

	{

		::operator delete(buffer);

	}



	template<class T1, class T2>

	inline void _construct(T1* p, const T2& value)

	{

		new(p) T1(value);

	}



	template<class T>

	inline void _destory(T* ptr)

	{

		ptr->~T();

	}



	template<class T>

	class allocator

	{

	public:

		typedef T			value_type;

		typedef T*			pointer;

		typedef const T*	const_pointer;

		typedef T&			reference;

		typedef const T&	const_reference;

		typedef size_t		size_type;

		typedef ptrdiff_t	difference_type;



		//rebind allocator of type U

		template<class U>

		struct rebind

		{

			typedef allocator<U> other;

		};



		//hint used for locality. 

		pointer allocate(size_type n, const void* hint = 0)

		{

			return _allocate( (difference_type)n, (pointer)0);

		}



		void deallocate(pointer p, size_type n)

		{

			_deallocate(p);

		}



		void construct(pointer p, const T& value)

		{

			_construct(p, value);

		}



		void destroy(pointer p)

		{

			_destory(p);

		}



		pointer address(reference x)

		{

			return (pointer)&x;

		}



		const_pointer const_address(const_reference x)

		{

			return (const_pointer)&x;

		}



		size_type max_size() const

		{

			return size_type(UINT_MAX/sizeof(T));

		}

	};

}



void q2_1_1_Test()

{

	int ia[5] = {0, 1, 2, 3, 4};

	unsigned int i;



	vector<int, SimpleAlloc::allocator<int> > iv(ia, ia+5);

	for (i = 0; i<iv.size(); i++)

		cout<<iv[i]<<' ';

	cout<<endl;

}