c++ 一个简单的allocator

#include <new>
#include <stdio.h>
#include <stdlib.h>

#ifndef NULL
#define NULL 0
#endif

//!内存分配.封装operator new函数
template <typename T>
T *allocate(size_t n,T*)
{
	T *tmp = (T*) operator new(n * sizeof(T));
	if (tmp == NULL)
	{
		fprintf(stderr,"Memory allocate error");
		exit(1);
	}
	return tmp;
}

//!封装 operator delete函数
template <typename T>
void deallocate(T *p)
{
	return operator delete((void *)p);
}

//!在p所指向的内存中用value值构造对象
template <typename T>
T *construct(T *p,const T &value)
{
	return (T*)new (p) T(value);
}

//!析构p指向的对象,但不释放内存
template <typename T>
void destroy(T *p)
{
	p->~T();
}

//!一个简单的空间配置器
template <typename T>
class allocator
{
	//!内部类型的定义
	typedef size_t   size_type;
	typedef T        value_type;
	typedef T*       pointer;
	typedef const T* const_pointer;
	typedef T&       reference;
	typedef const T& const_reference;

public:
	allocator();
	~allocator();

    pointer allocate(size_type n);
	void    deallocate(pointer p);
	void    construct(pointer p,const_reference value);
	void    destroy(pointer p);
};

template <typename T>
allocator<T>::allocator()
{

}

template <typename T>
allocator<T>::~allocator()
{

}

//!内存分配
template<typename T>
typename T* allocator<T>::allocate(size_type n)
{
	return ::allocate(n,(pointer)0);
}

//!内存回收
template<typename T>
void allocator<T>::deallocate(pointer p)
{
	return ::deallocate(p);
}

//!对象构造
template<typename T>
void allocator<T>::construct(pointer p,const_reference value)
{
	::construct(p,value);
}

//!对象析构
template<typename T>
void allocator<T>::destroy(pointer p)
{
	::destroy(p);
}


//测试程序

#include "allocator.h"
int main()
{
	allocator<int> alloc;
	int *p = alloc.allocate(1);
	alloc.construct(p,10);
	alloc.destroy(p);
	alloc.deallocate(p);
	return 0;
}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值