C/C++中記憶體管理是個最麻煩的事情，記憶體申請釋放，記憶體洩露，記憶體越界，甚至是記憶體碎片，就會導致程式出Core或者變慢。如何有效的管理記憶體，有很多方法，我認為最簡單的方式是用一個記憶體池來管理記憶體。

    談到記憶體池的時候，就有必要說下程式的生命週期和作用域，資料分為三類：1類是程序資料（全域性資料）。2、執行緒資料，每一個執行緒一份。3、請求資料，每一次呼叫一份。

    如果一個記憶體池想什麼生命週期和作用域的資料都放在裡面，可能是不合適的。所以我建議的使用方式是：程序一個記憶體池、每一個執行緒一個記憶體池、每個請求一個記憶體池。

    在程序/執行緒/請求初始時初始記憶體池，在程序/執行緒/請求結束時銷燬記憶體池。

    所以，就有了下面這個非常簡單的記憶體池了，程式碼有一點點繞，不過仔細閱讀還是能理解的。

    標頭檔案 AutoMemory.h

#ifndef _AUTO_MEMORY_H__
#define _AUTO_MEMORY_H__

#include <stddef.h>

//#define _MEM_TEST_
//#define _MEM_DEBUG_
#define _MEM_USE_

//default 1M
#define MEMORY_BLOCK_SIZE 1000000


/*
 * 執行緒相容，自動釋放
 */
class AutoMemory
{
public:
	AutoMemory();
	AutoMemory(int block_size);
	~AutoMemory();
	void* Alloc(size_t size);
	void Free(void* ptr);
	void FreeAll();

	void Debug();
	int BlockCount();
	size_t LeftSize();
	size_t MemSize();

private:
	struct MemBlock{
		MemBlock* prev;
	};
private:
	int headerSize;
	int blockSize;
	size_t memSize;
	int blockCount;
	char* begin;
	char* end;
	//MemBlock* currBlock;
};

#endif

 

   CPP檔案AutoMemory.cpp

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "AutoMemory.h"

AutoMemory::AutoMemory(){
	blockSize =  MEMORY_BLOCK_SIZE;
	blockCount = 0;
	memSize = 0;
	headerSize = sizeof(MemBlock);
	begin = end = ( char* ) headerSize;
}

AutoMemory::AutoMemory(int block_size){
	blockSize =  block_size;
	blockCount = 0;
	memSize = 0;
	headerSize = sizeof(MemBlock);
	begin = end = ( char* ) headerSize;
}

AutoMemory::~AutoMemory(){
	FreeAll();
}

size_t AutoMemory::MemSize(){
	return memSize;
}

int AutoMemory::BlockCount(){
	return blockCount;
}

size_t AutoMemory::LeftSize(){
	return (size_t)(end-begin);
}

void AutoMemory::Debug(){
	printf("Block count %d, Left size %d, Total size %d\n",
			this->BlockCount(),
			this->LeftSize(),
			this->MemSize() );
}

void* AutoMemory::Alloc(size_t size){
#ifndef _MEM_USE_
	return malloc(size);
#endif

	if ( (size_t)( end - begin ) < size ){
		if ( size >= blockSize){
			char* ptr = (char*)malloc(headerSize + size);
			MemBlock* pNew = (MemBlock*)ptr;
			MemBlock* pHeader = (MemBlock*)(begin - headerSize);
			if ( pHeader ){
				pNew->prev = pHeader->prev;
				pHeader->prev = pNew;
			}else{
				end = begin = (char*)( ptr + headerSize );
				pNew->prev = NULL;
			}
			blockCount += 1;
			memSize += size;
			return end;
		} else{
			char* ptr = (char*)malloc(headerSize + blockSize);
			MemBlock* pNew = (MemBlock*)ptr;
			pNew->prev = (MemBlock*)(begin - headerSize);
			begin = (char*)(ptr + headerSize);
			end = begin + blockSize;
			blockCount += 1;
			memSize += blockSize;

		}
	}
	return end -= size;
}

void AutoMemory::Free(void* ptr){
#ifndef _MEM_USE_
	free( ptr );
#endif
}

void AutoMemory::FreeAll(){
	MemBlock* pHeader = (MemBlock*)(begin - headerSize);
	while( pHeader ){
		MemBlock* pTemp = pHeader->prev;
        free( pHeader );
		pHeader = pTemp;
	}
	begin = end = (char*)headerSize;
	memSize = 0;
	blockCount = 0;
}

#ifdef _MEM_TEST_
int main(){
	AutoMemory am(100);
	printf("idx 1, alloc 10\n");
	char* buf = (char*)am.Alloc(10);
	am.Debug();

	printf("idx 2, alloc 90\n");
	am.Alloc(90);
	am.Debug();

	printf("idx 3, alloc 10\n");
	am.Alloc(10);
	am.Debug();

	printf("idx 4, alloc 100\n");
	am.Alloc(100);
	am.Debug();

	printf("idx 5, alloc 10\n");
	am.Alloc(10);
	am.Debug();
}
#endif