|
#include <limits>
#include <iostream>
namespace MyLib{
template <class T>
class MyAlloc{
public:
//type정의
typedef T value_type; //원소의 타입 allocator<T>와 동일
typedef T* pointer; //원소의 포인터에 대한 타입
typedef const T* const_pointer; //상수 포인터에 대한 타입
typedef T& reference; //원소의 레퍼런스에 대한 타입
typedef const T& const_reference; //원소의 상수레퍼런스에 대한 타입
typedef std::size_t size_type; //가장 큰 객체의 사이즈를 표기하기 위한 타입
typedef std::ptrdiff_t difference_type; //두 포인터의 거리를 표현하기 위한 타입
//rebind allocator type U
template <class U>
struct rebind{ //어떠한 할당자도 간접적으로 다른 타입의 기억 장소를 할당해 주는 기능을 제공
typedef MyAlloc<U> other;
}
//return address of values
pointer address( reference value) const { //상수값에 대한 포인터 반환
return &value;
}
const_pointer address( const_reference value) const { //비상수값에 대한 포인터 반환
return &value;
}
//생성자와 소멸자.
//할당자는 상태가 없으므로 아무것도 안한다.
MyAlloc() throw() {} //기본 생성자
MyAlloc(const MyAlloc&) throw() {} //복사 생성자
template <class U>
MyAlloc(const MyAlloc<U>&) throw() {}
~MyAlloc() throw() {} //소멸자
size_type max_size() const throw() { //할당가능한 최대 원소 수 반환
return std::numeric_limits<std::size_t>::max() / sizeof(T);
}
pointer allocate(size_type num, const void* = 0){ //T타입의 원소들을 할당은 하나 초기화는 안함
std::cerr << "allocate " << num << " element(s)" << " of size " << sizeof(T) << std::endl;
pointer ret = (pointer)(::operator new(num*sizeof(T)));
std::cerr << "allocated at : " << (void*)ret << std::endl;
return ret;
}
void construct(pointer p, const T& value){ //p가 참조하는 원소를 value로 초기화
new((void*)p)T(value);
}
void destroy(pointer p){ //기억장소의 해제 없이 p가 참조하는 객체소멸. (객체의 소멸자 호출)
p->~T();
}
void deallocate(pointer p, size_type num){ //p가 참조하는 기억 장소를 해제
std::cerr << "deallocate " << num << " element(s) of size " << sizeof(T) << " at : " << (void*)p <<
std::endl;
::operator delete((void*)p);
}
};
template <class T1, class T2>
bool operator== (const MyAlloc<T1>&, const MyAlloc<T2>&) throw() {
return true;
}
template <class T1, class T2>
bool operator!= (const MyAlloc<T1>&, const MyAlloc<T2>&) throw() {
return false;
}
}; | 
댓글