C++ 内存分配(new，operator new、placement new)详解

推荐两篇文章：

1、http://blog.csdn.net/wudaijun/article/details/9273339

2、http://www.cnblogs.com/luxiaoxun/archive/2012/08/10/2631812.html

再来一个内存池的代码：

#ifndef MEM_BASE_HPP_201107042302
#define MEM_BASE_HPP_201107042302

#include <vector>
#include <stdlib.h>
#include <iostream>

using namespace std;

namespace sparrow
{

	/**用于内存对齐的联合*/
	union align_info{
		int (*i)();
		void* p;
		long l;
	};

	/**内存链表结点*/
	class mem_node{
	public:
		mem_node(void) : pnext_(NULL){};
		~mem_node(void){
			pnext_ = NULL;
		};

		mem_node* next(void) const{return pnext_;};
		void next(mem_node *pnext){pnext_ = pnext;};
	private:
		mem_node *pnext_;
	};

	/**空闲内存链表
	*/
	class mem_free_list{
	public:
		mem_free_list(void) : pnode_(NULL){};
		~mem_free_list(void){pnode_ = NULL;};

		void add(mem_node *pnode){
			if(NULL == pnode) return;
			if(NULL == pnode_){
				pnode_ = pnode;
				pnode_->next(NULL);
			}else{
				pnode->next(pnode_);
				pnode_ = pnode;
			}
		};

		void* remove(void){
			mem_node *pnode = pnode_;
			if(NULL == pnode) return pnode;
			pnode_ = pnode_->next();
			return pnode;
		};

		void clear(void)
		{
			pnode_ = NULL;
		};

	private:
		mem_node *pnode_;
	};

	class memory_pool
	{
		typedef std::vector<char*>	_arr_mem;

	public:
		memory_pool(void) : 
		is_inited_(false), objsize_(0), inc_count_(0)
		{	
		};
		~memory_pool(void)
		{
			relase_memory();
		};

		/*
		初始化
		objsize  对象大小
		count	 对象数量
		inc_count 当对象用完之后，每次增加的数量
		*/
		int init(const size_t objsize, const size_t count, const size_t inc_count)
		{
			if(is_inited_) return 0;

			if(0 == count || 0 == inc_count)
			{
				return -1;
			}

			objsize_	= objsize;
			inc_count_	= inc_count;
			if(objsize_ < sizeof(mem_node)) objsize_ = sizeof(mem_node);
			int ret =  inc_mem(count);
			if(0 != ret)
			{
				return -1;
			}
			is_inited_ = true;
			return 0;
		};

		bool is_inited(void) const
		{
			return is_inited_;
		};
		
		void* malloc(void)
		{
			void *p = free_list_.remove();
			if(NULL == p)
			{
				inc_mem(inc_count_);
				p = free_list_.remove();
			}
			return p;
		};
		void free(void *p){
			if(NULL == p) return;
			free_list_.add((mem_node*)p);
		};

		void relase_memory(void)
		{
			for(_arr_mem::iterator iter = arr_mem_.begin(); iter != arr_mem_.end(); ++ iter)
			{
				char *mem = *iter;
				::free(mem);
			}
			arr_mem_.clear();
			free_list_.clear();
			
			is_inited_ = false;
			objsize_	= 0;
			inc_count_  = 0;
		};

	private:
		int inc_mem(const size_t count)
		{
			if(0 == count) return -1;

			char *mem = (char*)::malloc(objsize_ * count);
			if(NULL == mem) return -1;
			
			arr_mem_.push_back(mem);

			mem_node *pnode = NULL;
			for(size_t i = 0; i < count; ++ i)
			{
				pnode = new (mem + i * objsize_) mem_node();
				free_list_.add(pnode);
			}
			return 0;
		};

	private:
		bool			is_inited_;
		_arr_mem		arr_mem_;
		mem_free_list	free_list_;
		size_t			objsize_;
		size_t			inc_count_;
	};

	template<typename T>
	class mem_base
	{
		enum{
			DEF_COUNT = 128,
			INC_COUNT = 128
		};
	public:
		mem_base()
		{
			cout << "mem_base init" << endl;
		}
		
		static void* operator new(size_t size, void *p){return p;} 

		static void* operator new(size_t size){
			cout << "mem_base operator new running" << endl;
			if(!mem_pool_.is_inited())
			{
				mem_pool_.init(sizeof(T), DEF_COUNT, INC_COUNT);
			}
			return mem_pool_.malloc();
		};
		static void operator delete(void *p){
			mem_pool_.free(p);
		};

	private:
		static memory_pool		mem_pool_;
	};
	template<typename T>
	memory_pool mem_base<T>::mem_pool_;
}

#endif