C/C++ 最容易出问题的地方是内存管理，容易造成内存泄露和内存越界，这一直是 C/C++ 程序员比较头疼的事情，但 C/C++ 最大的优势也是内存管理，可以让程序员直接管理内存，从而使程序运行更为高效。acl 库中的内存池管理器 dbuf_guard 在管理内存的效率上比系统级内存管理方式（malloc/free, new/delete）更为高效，同时也使内存管理更为健壮性，这可以使 C/C++ 程序员避免出现一些常见的内存问题。本节主要介绍了 acl 库中 dbuf_guard 类的设计特点及使用方法。
dbuf_guard 类内部封装了内存池对象类 dbuf_pool，提供了与 dbuf_pool 一样的内存分配方法，dbuf_guard 类与 dbuf_pool 类的最大区别是 dbuf_guard 类对象既可以在堆上动态分配，也可以在栈上分配，而 dbuf_pool 类对象必须在堆上动态分配，另外，dbuf_guard 类还统一管理在 dbuf_pool 内存池上所创建的所有 dbuf_obj 子类对象，在 dbuf_guard 类对象析构时，所有由其管理的 dbuf_obj 子类对象被统一析构。下面先从一个简单的例子来说明 dbuf_guard 的使用方法，例子如下：
void test(void)
{
// 定义一个内存池管理对象
acl::dbuf_guard dbuf;
#define STR "hello world"
// 在 dbuf 对象上动态创建一个字符串内存
char* str = dbuf.dbuf_strdup(STR);
printf("str: %s\r\n", str);
// 在 dbuf 对象上动态创建内存
// sizeof(STR) 取得 STR 所包含的字符串长度 + 1
str = (char*) dbuf.dbuf_alloc(sizeof(STR));
memcpy(str, STR, sizeof(STR));
printf("str: %s\r\n", str);
// 在本函数返回前，dbuf 对象自动被销毁，同时释放其所管理的
// 内存池以及在内存池上分配的内存
}
上面的例子展示了使用 dbuf_guard 类对象直接分配内存块的过程，可以看出，所有在 dbuf_guard 对象的内存池上动态分配的内存都会在 dbuf_guard 对象销毁时被自动释放。这只是一个简单的使用 dbuf_guard 进行内存管理的例子，那么对于 C++ 对象的内存如何进行管理呢？请看下面的的例子：
class myobj : public acl::dbuf_obj
{
public:
myobj()
{
// 调用系统 API 分配动态内存
str_ = strdup("hello world");
}
void run()
{
printf("str: %s\r\n", str_);
}
private:
char* str_;
~myobj()
{
// 释放构造函数中分配的内存，否则会造成内存泄露
free(str_);
}
};
void test(void)
{
acl::dbuf_guard dbuf;
// 调用 dbuf_guard::create<T>() 模板函数创建 myobj 对象
myobj* obj = dbuf.create<myobj>();
// 调用 myobj::run 方法
obj->run();
// 本函数返回前，dbuf 对象被销毁，obj 一起被销毁
}
该例子展示了 C++ 对象在 dbuf_guard 动态创建的过程，其中有两个要点：
(1)、由 dbuf_guard 对象统一管理的 C++ 对象必须是 dbuf_obj 的子类，这样在 dbuf_guard 类对象的析构时才可以通过调用 dbuf_obj 的析构函数来达到将 dbuf_obj 子类析构的目的（其中 dbuf_obj 的析构函数为虚函数）；
(2)、创建 dbuf_obj 的子类对象时，调用 dbuf_guard 对象的模板函数 create，同时指定子类名称 myobj 来创建 myobj 对象，create 内部会自动将该对象指针加入内部数组对象集合中，从而达到统一管理的目的。
上面例子的构造函数不带参数，在 dbuf_guard::create 模板函数中允许添加 0 至 10 个参数（其实内部有 11 个 create 模板函数），如果一个构造函数需要多于 10 个参数，则说明该构造函数设计的太复杂了。下面的例子展示了构造函数带参数的类对象创建过程：
// 继承于 acl::dbuf_obj 类
class myobj : public acl::dbuf_obj
{
public:
myobj(int i, int j)
{
printf("myobj, i=%d, j=%d\r\n", i, j);
// 在内存池上分配动态内存
str_ = dbuf.dbuf_strdup("hello world");
}
void run()
{
printf("str: %s\r\n", str_);
}
private:
char* str_;
~myobj()
{
// 因为 str_ 的内存也是创建在内存池上，所以此处禁止再调用 free 来释放该内存
// free(str_);
}
};
void test(void)
{
acl::dbuf_guard dbuf;
// 调用 dbuf_guard::create<T>(P1, P2) 模板函数创建构造函数带两个参数的 myobj 对象
myobj* obj = dbuf.create<myobj>(10, 100);
// 调用 myobj::run 方法
obj->run();
// 本函数返回前，dbuf 对象被销毁，obj 一起被销毁
}
在 dbuf_guard 类中除了上面提供的方法外，还提供了以下多个方法方便使用：
/**
* 调用 dbuf_pool::dbuf_reset
* @param reserve {size_t}
* @return {bool}
*/
bool dbuf_reset(size_t reserve = 0)
{
return dbuf_->dbuf_reset(reserve);
}
/**
* 调用 dbuf_pool::dbuf_alloc
* @param len {size_t}
* @return {void*}
*/
void* dbuf_alloc(size_t len)
{
return dbuf_->dbuf_alloc(len);
}
/**
* 调用 dbuf_pool::dbuf_calloc
* @param len {size_t}
* @return {void*}
*/
void* dbuf_calloc(size_t len)
{
return dbuf_->dbuf_calloc(len);
}
/**
* 调用 dbuf_pool::dbuf_strdup
* @param s {const char*}
* @return {char*}
*/
char* dbuf_strdup(const char* s)
{
return dbuf_->dbuf_strdup(s);
}
/**
* 调用 dbuf_pool::dbuf_strndup
* @param s {const char*}
* @param len {size_t}
* @return {char*}
*/
char* dbuf_strndup(const char* s, size_t len)
{
return dbuf_->dbuf_strndup(s, len);
}
/**
* 调用 dbuf_pool::dbuf_memdup
* @param addr {const void*}
* @param len {size_t}
* @return {void*}
*/
void* dbuf_memdup(const void* addr, size_t len)
{
return dbuf_->dbuf_memdup(addr, len);
}
/**
* 调用 dbuf_pool::dbuf_free
* @param addr {const void*}
* @return {bool}
*/
bool dbuf_free(const void* addr)
{
return dbuf_->dbuf_free(addr);
}
/**
* 调用 dbuf_pool::dbuf_keep
* @param addr {const void*}
* @return {bool}
*/
bool dbuf_keep(const void* addr)
{
return dbuf_->dbuf_keep(addr);
}
/**
* 调用 dbuf_pool::dbuf_unkeep
* @param addr {const void*}
* @return {bool}
*/
bool dbuf_unkeep(const void* addr)
{
return dbuf_->dbuf_unkeep(addr);
}
/**
* 获得 dbuf_pool 对象
* @return {acl::dbuf_pool&}
*/
acl::dbuf_pool& get_dbuf() const
{
return *dbuf_;
}
/**
* 可以手动调用本函数，将在 dbuf_pool 上分配的 dbuf_obj 子类对象交给
* dbuf_guard 对象统一进行销毁管理；严禁将同一个 dbuf_obj 子类对象同
* 时将给多个 dbuf_guard 对象进行管理，否则将会产生对象的重复释放
* @param obj {dbuf_obj*}
* @return {int} 返回 obj 被添加后其在 dbuf_obj 对象数组中的下标位置，
* dbuf_guard 内部对 dbuf_obj 对象的管理具有防重添加机制，所以当多次
* 将同一个 dbuf_obj 对象置入同一个 dbuf_guard 对象时，内部只会放一次
*/
int push_back(dbuf_obj* obj);
/**
* 获得当前内存池中管理的对象数量
* @return {size_t}
*/
size_t size() const
{
return size_;
}
/**
* 获得当前内存池中管理的对象集合，该函数必须与 size() 函数配合使用，
* 以免指针地址越界
* @return {dbuf_obj**} 返回 dbuf_obj 对象集合，永远返回非 NULL 值，
* 该数组的大小由 size() 函数决定
*/
dbuf_obj** get_objs() const
{
return objs_;
}
/**
* 返回指定下标的对象
* @param pos {size_t} 指定对象的下标位置，不应越界
* @return {dbuf_obj*} 当下标位置越界时返回 NULL
*/
dbuf_obj* operator[](size_t pos) const;
/**
* 返回指定下标的对象
* @param pos {size_t} 指定对象的下标位置，不应越界
* @return {dbuf_obj*} 当下标位置越界时返回 NULL
*/
dbuf_obj* get(size_t pos) const;
/**
* 设置内建 objs_ 数组对象每次在扩充空间时的增量，内部缺省值为 100
* @param incr {size_t}
*/
void set_increment(size_t incr);
同时，dbuf_obj 类中也提供了额外的操作方法：
/**
* 获得该对象在 dbuf_guard 中的数组中的下标位置
* @return {int} 返回该对象在 dbuf_guard 中的数组中的下标位置，当该
* 对象没有被 dbuf_guard 保存时，则返回 -1，此时有可能会造成内存泄露
*/
int pos() const
{
return pos_;
}
/**
* 返回构造函数中 dbuf_guard 对象
* @return {dbuf_guard*}
*/
dbuf_guard* get_guard() const
{
return guard_;
}
最后，以一个稍微复杂的例子做为结尾(该例子源码在 acl 库中的位置：lib_acl_cpp\samples\dbuf\dbuf2)，该例子展示了使用 dbuf_guard 类的几种方法：
#include "stdafx.h"
#include <sys/time.h>
/**
* dbuf_obj 子类，在 dbuf_pool 上动态分配，由 dbuf_guard 统一进行管理
*/
class myobj : public acl::dbuf_obj
{
public:
myobj(acl::dbuf_guard* guard = NULL) : dbuf_obj(guard)
{
ptr_ = strdup("hello");
}
void run()
{
printf("----> run->hello world <-----\r\n");
}
private:
char* ptr_;
// 将析构声明为私人，以强制要求该对象被动态分配，该析构函数将由
// dbuf_guard 统一调用，以释放本类对象中产生的动态内存(ptr_)
~myobj()
{
free(ptr_);
}
};
static void test_dbuf(acl::dbuf_guard& dbuf)
{
for (int i = 0; i < 102400; i++)
{
// 动态分配内存
char* ptr = (char*) dbuf.dbuf_alloc(10);
(void) ptr;
}
for (int i = 0; i < 102400; i++)
{
// 动态分配字符串
char* str = dbuf.dbuf_strdup("hello world");
if (i < 5)
printf(">>str->%s\r\n", str);
}
// 动态分配内存
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(2048);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(1024);
(void) dbuf.dbuf_alloc(10240);
for (int i = 0; i < 10000; i++)
{
// 动态分配 dbuf_obj 子类对象，并通过将 dbuf_guard 对象传入
// dbuf_obj 的构造函数，从而将之由 dbuf_guard 统一管理，
myobj* obj = dbuf.create<myobj>(&dbuf);
// 验证 dbuf_obj 对象在 dbuf_guard 中的在在一致性
assert(obj == dbuf[obj->pos()]);
// 调用 dbuf_obj 子类对象 myobj 的函数 run
if (i < 10)
obj->run();
}
for (int i = 0; i < 10000; i++)
{
myobj* obj = dbuf.create<myobj>();
assert(dbuf[obj->pos()] == obj);
if (i < 10)
obj->run();
}
for (int i = 0; i < 10000; i++)
{
myobj* obj = dbuf.create<myobj>(&dbuf);
// 虽然多次将 dbuf_obj 对象置入 dbuf_guard 中，因为 dbuf_obj
// 内部的引用计数，所以可以防止被重复添加
(void) dbuf.push_back(obj);
(void) dbuf.push_back(obj);
(void) dbuf.push_back(obj);
assert(obj == dbuf[obj->pos()]);
if (i < 10)
obj->run();
}
}
static void wait_pause()
{
printf("Enter any key to continue ...");
fflush(stdout);
getchar();
}
static void test1()
{
// dbuf_gaurd 对象创建在栈上，函数返回前该对象自动销毁
acl::dbuf_guard dbuf;
test_dbuf(dbuf);
}
static void test2()
{
// 动态创建 dbuf_guard 对象，需要手动销毁该对象
acl::dbuf_guard* dbuf = new acl::dbuf_guard;
test_dbuf(*dbuf);
// 手工销毁该对象
delete dbuf;
}
static void test3()
{
// 将内存池对象 dbuf_pool 做为 dbuf_guard 构造函数参数传入，当
// dbuf_guard 对象销毁时，dbuf_pool 对象一同被销毁
acl::dbuf_guard dbuf(new acl::dbuf_pool);
test_dbuf(dbuf);
}
static void test4()
{
// 动态创建 dbuf_guard 对象，同时指定内存池中内存块的分配倍数为 10，
// 即指定内部每个内存块大小为 4096 * 10 = 40 KB，同时
// 指定内部动态数组的初始容量大小
acl::dbuf_guard dbuf(10, 100);
test_dbuf(dbuf);
}
static void test5()
{
acl::dbuf_pool* dp = new acl::dbuf_pool;
// 在内存池对象上动态创建 dbuf_guard 对象，这样可以将内存分配的次数
// 进一步减少一次
acl::dbuf_guard* dbuf = new (dp->dbuf_alloc(sizeof(acl::dbuf_guard)))
acl::dbuf_guard(dp);
test_dbuf(*dbuf);
// 因为 dbuf_gaurd 对象也是在 dbuf_pool 内存池对象上动态创建的，所以
// 只能通过直接调用 dbuf_guard 的析构函数来释放所有的内存对象；
// 既不能直接 dbuf_pool->desotry()，也不能直接 delete dbuf_guard 来
// 销毁 dbuf_guard 对象
dbuf->~dbuf_guard();
}
class myobj2 : public acl::dbuf_obj
{
public:
myobj2() {}
void run()
{
printf("hello world\r\n");
}
private:
~myobj2() {}
};
class myobj3 : public acl::dbuf_obj
{
public:
myobj3(int i) : i_(i) {}
void run()
{
printf("hello world: %d\r\n", i_);
}
private:
~myobj3() {}
private:
int i_;
};
class myobj_dummy
{
public:
myobj_dummy() {}
void run()
{
printf("can't be compiled\r\n");
}
private:
~myobj_dummy() {}
};
static void test6()
{
acl::dbuf_guard dbuf;
myobj* o = dbuf.create<myobj>();
o->run();
myobj* o1 = dbuf.create<myobj>(&dbuf);
o1->run();
myobj2* o2 = dbuf.create<myobj2>();
o2->run();
myobj3* o3 = dbuf.create<myobj3>(10);
o3->run();
for (int i = 0; i < 10; i++)
{
myobj3* o4 = dbuf.create<myobj3>(i);
o4->run();
}
// below codes can't be compiled, because myobj_dummy isn't
// acl::dbuf_obj's subclass
// myobj_dummy* dummy = dbuf.create<myobj_dummy>();
// dummy->run();
}
int main(void)
{
acl::log::stdout_open(true);
test1();
wait_pause();
test2();
wait_pause();
test3();
wait_pause();
test4();
wait_pause();
test5();
wait_pause();
test6();
return 0;
}
原文地址： http://zsxxsz.iteye.com/blog/2256868
svn：svn checkout svn://svn.code.sf.net/p/acl/code/trunk acl-code
github：git clone https://github.com/acl-dev/acl
sourceforge：http://sourceforge.net/projects/acl/
国内镜像：http://git.oschina.net/acl-dev/acl/tree/master
微博：http://weibo.com/zsxxsz/
qq 群：242722074
相关推荐
mongoDB-acl-nodejs 一个非常简单的Acl模块，用于在应用程序内存和MongoDB中使用的NodeJS 我创建此模块是因为我需要使用MongoDB的非常简单的Acl模块功能说明Acl.init（选项，回调） -options ：对象用于连接到您的...
5.6.1 标准C内存管理函数与Windows内存管理API的关系 149 5.6.2 功能性区别 149 5.6.3 效率的区别 149 第6章 进程、线程和模块 150 6.1 基本概念 150 6.1.1 应用程序与进程 150 6.1.2 控制台应用程序与...
5.6.1 标准C内存管理函数与Windows内存管理API的关系 149 5.6.2 功能性区别 149 5.6.3 效率的区别 149 第6章 进程、线程和模块 150 6.1 基本概念 150 6.1.1 应用程序与进程 150 6.1.2 控制台应用程序...
3.1 内存区间的动态分配 47 3.1.1 内核对用户空间的管理 48 3.1.2 内核对于物理页面的管理 60 3.1.3 虚存页面的映射 67 3.1.4 Hyperspace的临时映射 78 .3.1.5 系统空间的映射 86 3.1.6 系统调用...