设计一个简单的空间配置器, JJ::allocator

// Test.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <new>

#include <cstddef>

#include <cstdlib>

#include <climits>

#include <iostream>

#include <vector>

using namespace std;

namespace JJ

{

template <typename 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 <typename T>

inline void _deallocate(T* buffer)

{

::operator delete(buffer);

}

template <typename T1,typename T2>

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

{

new(p) T1(value);

}

template <typename T>

inline void _destroy(T* ptr)

{

ptr->T();

}

template <typename 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<typename U>

struct rebind

{

typedef allocator<U> other;

};

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)

{

_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()

{

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

unsigned int i;

vector<int,JJ::allocator<int>> ivv(ia,ia+5);

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

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

std::cout << iv[i] << " ";

cout << endl;

system("pause");

return 0;

}