STL源码剖析中allocator类运行在vs2010上

《STL源码剖析》第二章的代码敲了一遍（Linux运行正常），在windows上出现以下错误：

d:\program files\microsoft visual studio 10.0\vc\include\vector(454): error C2664: 'JJ::allocator<T>::allocator(const JJ::allocator<T> &)' : cannot convert parameter 1 from 'JJ::allocator<T>' to 'const JJ::allocator<T> &'
1>          with
1>          [
1>              T=std::_Container_proxy
1>          ]
1>          and
1>          [
1>              T=int
1>          ]
1>          and
1>          [
1>              T=std::_Container_proxy
1>          ]
1>          Reason: cannot convert from 'JJ::allocator<T>' to 'const JJ::allocator<T>'
1>          with
1>          [
1>              T=int
1>          ]
1>          and
1>          [
1>              T=std::_Container_proxy
1>          ]
1>          No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
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=JJ::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=JJ::allocator<int>
1>          ]
1>          e:\快盘\炸金花\程序\stl\stl\allocator.cpp(11) : see reference to class template instantiation 'std::vector<_Ty,_Ax>' being compiled
1>          with
1>          [
1>              _Ty=int,
1>              _Ax=JJ::allocator<int>
1>          ]
1>
1>Build FAILED.

原因是，windows的编译器用到了allocator不同类型的拷贝，所以只需写上拷贝构造函数就可以。

#pragma once

#include<cstddef>

namespace JJ
{
	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;

		template <class U>
		struct rebind
		{
			typedef allocator<U> other;
		};

		
		allocator()
		{
			return ;
		}
			
		template <class U>
		allocator(const allocator<U>& c )
		{
		}

		pointer allocate(size_type n,const void *hint=0)
		{
			cout<<n<<endl;
			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(0xffffffff/sizeof(T));
		//	return size_type(0);
		}
	};

}