#include <iostream> #include <new> #include <cstddef> #include <vector> using namespace std; template <class T> inline T* _allocator(ptrdiff_t size, T*) { std::cout<<"_allocator()"<<std::endl; set_new_handler(0); T* tmp = (T*)(::operator new((size_t)size * sizeof(T))); if (tmp == NULL) { exit(1); } return tmp; } template<class T> inline void _deallocator(T * buffer) { std::cout<<"_deallocator()"<<std::endl; ::operator delete(buffer); } template<class T1, class T2> inline void _constructor(T1* p, const T2& value) { std::cout<<"_constructor()"<<std::endl; new(p) T1(value); } template <class T> inline void _destroy(T* ptr) { std::cout<<"_destroy()"<<std::endl; ptr->~T(); } template<class T> class jjAllocator { 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 jjAllocator<U> other; }; jjAllocator() {} jjAllocator(const jjAllocator&) {} template <class U> jjAllocator(const jjAllocator<U>&) {} ~jjAllocator() {} pointer allocate(size_type n, const void* hint = 0) { return _allocator((ptrdiff_t)n, (pointer)0); } void deallocate(pointer p, size_type n) { _deallocator(p); } void construct(pointer p, const T& value) { _constructor(p, value); } void destroy(pointer p) { _destroy(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)); } }; int main() { std::vector<int, jjAllocator<int>>mmm; mmm.push_back(1); mmm.push_back(2); system("pause"); return 1; }