#include <vector>
#include <iostream>
#include <algorithm>
using namespace::std; template <class T> class malloc_allocator
{
public:
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type; template <class U>
struct rebind { typedef malloc_allocator<U> other; }; malloc_allocator() {}
malloc_allocator(const malloc_allocator&) {}
template <class U> malloc_allocator(const malloc_allocator<U>&) {}
~malloc_allocator() {} pointer address(reference x) const { return &x; } const_pointer address(const_reference x) const
{
return x;
} pointer allocate(size_type n, const_pointer = 0)
{
cout<<"Allocate allocate"<<endl;
void* p = std::malloc(n * sizeof(T));
if (!p)
throw std::bad_alloc();
return static_cast<pointer>(p); } void deallocate(pointer p, size_type)
{
cout<<"Allocate deallocate"<<endl;
std::free(p);
}
size_type max_size() const {
return static_cast<size_type>(-1) / sizeof(T);
} void construct(pointer p, const value_type& x)
{
cout<<"Allocate construct"<<endl;
new(p) value_type(x);
}
void destroy(pointer p)
{
cout<<"Allocate destroy"<<endl;
p->~value_type();
} private: void operator=(const malloc_allocator&); }; template<>
class malloc_allocator<void>
{
typedef void value_type;
typedef void* pointer;
typedef const void* const_pointer;
template <class U>
struct rebind { typedef malloc_allocator<U> other; };
}; template <class T>
inline bool operator==(const malloc_allocator<T>&,const malloc_allocator<T>&)
{
return true;
} template <class T>
inline bool operator!=(const malloc_allocator<T>&,const malloc_allocator<T>&)
{
return false;
} int main()
{
std::vector<int, malloc_allocator<int>>myvector; myvector.push_back(1); system("pause");
return 0;
}