久久一区精品,欧美日韩视频免费播放,亚洲小说春色综合另类电影

Centos�~�译boost

Mon, 07 Jan 2013 08:38:00 GMT

http://blog.sina.com.cn/s/blog_6f2caee40100uhj6.html

1.下蝲最新的boost

http://www.boost.org/

2.解压文�g

tar -xzvf boost_1_45_0.tar.gz

3.�~�译bjam

�q�入boost_1_45_0目录中，�q�行./bootstrap.sh�Q�完成后会得��C��个bjam

4.�~�译boost

./bjam --with-date_time --with-system --with-regex --with-thread --with-filesystem --with-serialization --with-iostreams --with-math --with-mpi --with-program_options --with-python --with-math --with-signals --layout=tagged install variant=debug,release link=static --runtime-link=static threading=multi stage

5.查看boost

�~�译完成后，�?usr/local/include/boost��有最新的boost头文件了�Q�在/usr/local/lib��有�~�译好的.a库文件了�?/div>

虽然usr/local/include�?usr/include都有目录�Q�但GCC是先讉K��/usr/local/include�Q�所以编译完成后�Q�就可以默认使用boost了�?/div>

6.��试boost

vi testboost.cpp

#include

int main()

{

std::cout<

return 0;

}

�~�译:g++ -o testboost testboost.cpp

��果�?/a> 2013-01-07 16:38 发表评论

mint 下codeblocks �~�译libapue

Fri, 04 Jan 2013 12:23:00 GMT

codeblocks很轻巧也很好用对于c/c++�~�写在linux下相对于eclipse.
于是乎下了一个，�׃��是乎惛_��几个sample玩玩。于是乎�?lt;unix 高��环境�~�程> sample来测试�?br />
于是乎徏了一个c++ project.

里的例子有个apue.h头文件。不是系�l�自带的。是作者自己写的几个util函数�?br />�|�上扄��译apue.h头文件一大片。但是都是考来考去�Q�不�q�核心的都差不多。不�q�有个方法是�~�译�?br />libapue.a静态库后，�q�需要在apute.h头文件尾巴加"error.c"。。完了拷贝error.c实现到目录。�?br />看完后。我惊了呆。。好吧。。这库还能这么用。�?br />
既然libapue.a�~�译完后�Q�apue.h里的函数声明在libapue.a都已�l�实玎ͼ�当然包括err_xxx�p�d��的。所�?br />在apue.h�?error.c"是画蛇添��뀂。这里不推荐此方法。�?br />
我的环境是mint14�? IDE用的�?codeblocks. �Ҏ��中基本都有这么一个步骤：

先在�q�个�|�站 http://www.apuebook.com/src.tar.gz 下蝲tar.gz格式的源码包�Q�然后解压至某个目录�Q�比如说/home/xiaoguozi/下，然后�q�入目录apue.2e�Q�把文�g Make.defines.linux 中的 WKDIR=/home/xxx/apue.2e 修改�? WKDIR=/home/xiaoguozi/apue.2e �Q�然后再�q�入apue.2e目录下的std目录�Q�打开linux.mk�Q�将里面的nawk全部替换为awk

如果用vim�~�辑的话�Q�可以用 :1,%s/nawk/awk/g 替换字符�H?br />
完了make, �q�程中，�q�遇��C��几个问题�?mint�?其他os不太清楚)

1: /usr/include/bits/timex.h:31:7:error: expect ':' , ',' , ';' , '}' or '__attribute__'
apue.2e/ipp/ipp.h�?#define status u.st �?timex.h中的 status 冲突�Q�更�?#define Status u.st

2�Q�ARG_MAX 未定�?/span>

在include/apue.h中加�?#define ARG_MAX 4096

在threadctl/getenv1.c 加入 #include "../include/apue.h"

在threadctl/getenv3.c 加入 #include "../include/apue.h"

完了之后�Q�make应该��可以成功了

完了在codeblocks��目里引用刚�~�译完的库，有几个方�?
1)��编译完的库,头文件apue.h拯��/usr/include,库文件libapue.a拯��?usr/lib下，�q�个是系�l�目录，gcc�~�译的时候会在这目录搜寻
2)在项目属性添加静态库引用

��d��头文�Ӟ��依次点击project->bulid options->Search directories�Q�在该标�{�N��中点击Compiler�Q�单击Add按钮��d��头文件�\�?br />��d��静态库路径�Q�依�ơ点击project->bulid options->Linker setting�Q�在该标�{�N��中点击Add按钮��d��静态库路径�?br />
如果之前你徏的是c project的话�Q�应该就可以��利�~�译通过了，但是对于建立c++的project,仍然提示链接错误�Q�找不到函数实现�Q?br />原因是libapue.a是c库，用g++�~�译的时候要引用c库的话，因�ؓc++�~�译的时候会在函数加一些额外字�W�，所以当然会链接错误�?/div>

解决也简单的在函数库前加 extern "C",或者直接把apue.h用extern "C"包含�Q�不清楚的补下相应知识�?br />
加点额外的知识关于gcc/g++�Q?br />

gcc和g++的区�?p>误区一:gcc只能�~�译c代码,g++只能�~�译c++代码
两者都可以�Q�但是请注意�Q?br />1.后缀�?c的，gcc把它当作是C�E�序�Q�而g++当作是c++�E�序�Q�后�~��?cpp的，两者都会认为是c++�E�序�Q�注意，虽然c++是c的超集，但是两者对语法的要求是有区别的。C++的语法规则更加严谨一些�?br />2.�~�译阶段�Q�g++会调用gcc�Q�对于c++代码�Q�两者是�{��h的，但是因�ؓgcc命��o不能自动和C�Q�＋�E�序使用的库联接�Q�所以通常用g++来完成链接，��Z��l�一赯��Q�干脆编�?链接�l�统用g++了，�q�就�l��h一�U�错觉，好像cpp�E�序只能用g++似的�?br />
误区�?gcc不会定义__cplusplus宏，而g++�?br />实际上，�q�个宏只是标志着�~�译器将会把代码按C�q�是C++语法来解释，如上所�q�ͼ�如果后缀�?c�Q��ƈ且采用gcc�~�译器，则该宏就是未定义的，否则�Q�就是已定义�?br />
误区�?�~�译只能用gcc�Q�链接只能用g++
严格来说�Q�这句话不算错误�Q�但是它��h��了概念，应该�q�样��_��~�译可以用gcc/g++�Q�而链接可以用g++或者gcc -lstdc++。因为gcc命��o不能自动和C�Q�＋�E�序使用的库联接�Q�所以通常使用g++来完成联接。但在编译阶�D�，g++会自动调用gcc�Q�二者等仗��?/p> gcc和g++的区�? 我们在编译c/c++代码的时候，有�h用gcc�Q�有人用g++�Q�于是各�U�说法都来了�Q�譬如c代码用gcc�Q�而c++代码用g++�Q�或者说�~�译�? gcc�Q�链接用g++�Q�一时也不知哪个说法正确�Q�如果再遇上个extern "C"�Q�分歧就更多了，�q�里我想作个了结�Q�毕竟知识的目的是��o人更清醒�Q�而不是更�p�涂�?/div>

��果�?/a> 2013-01-04 20:23 发表评论

Installing Gearman and gearmand on Windows with Cygwin

Fri, 28 Dec 2012 03:17:00 GMT

Recently I've come face-to-face with a significant processing task for a web application written in PHP. I haven't worked with process control very much, so I started researching ways of distributing the calculations to multiple processes. PHP offers several libraries for doing this (pcntl, POSIX), but it quickly became clear that if you're running Windows these libraries are not an option, and unfortunately at work I have a Windows machine. After a lot more research, I came across Gearman.

Gearman is essentially a distributed processing framework, and seems to have community support for many programming languages. It consists of two main components: the job server, and a Client and Worker API. The Client and Worker API can be used in a wide variety of languages, but the job server is only available as a C library or a Perl library. This makes it a bit tougher to get the server running on Windows, especially when you start running into some of the dependencies that it requires to build. As well, the Client/Worker API for PHP can only be installed as a PECL extension, or a very-out-of-date PEAR extension called Net_Gearman.

Nonetheless, after yet more research I decided that I would give it a shot by using Cygwin to get the job server running (if you haven't used Cygwin before, be sure to read about it before attempting to install Gearman this way), and PEAR to use the API. Pre-built PECL extensions aren't available for Windows anymore, and the build process for PHP extensions can be pretty painful, so it makes PEAR look good by comparison even if the code will be out of date.

I had a pretty frustrating time finally getting everything up and running due to various dependency issues, so I went back through the whole process and wrote it out step-by-step. I used a Windows XP SP3 machine for this, but I also got it working on a Windows 7 machine as well.

Installing the Gearman job server (gearmand) on Windows with Cygwin

Installing Cygwin

If you don't have Cygwin already, you can get it from http://www.cygwin.com. The setup file is located here, and the setup process is pretty straightforward; run it and follow the wizard. Full installation instructions are available at the Cygwin site.
Keep the Cygwin setup.exe file handy after you've installed the default software packages, as you'll need it in the future to add packages, similar to apt-get, yum, and other Linux/UNIX package managers.
Cygwin installs with some basic packages, including a Cygwin Bash Shell that goes into your Start Menu. I prefer the mintty emulator instead, as it has less of a DOS Command Prompt feel and better terminal features. Feel free to use whatever shell you like of course. You can get mintty by re-running the setup.exe, and at the package selection screen, type 'mintty' into the Search bar at the top left. Expand the "Shells" category, and click on the word "Skip" under the "New" column beside the mintty package to select it before continuing the install process.

Installing Cygwin Package Dependencies needed for Gearman

If you're not already in the Cygwin setup, re-run the Cygwin setup.exe and go through to the package selection screen. The following is a list of dependency packages you will need in order to build the Gearman job server (gearmand). None of these packages were installed by default with Cygwin:

gcc
make
libuuid1-devel
libiconv

There's a good installation tutorial here that walks through getting gcc and make installed for people unfamiliar with Cygwin. Finding the others is pretty straightforward, the Search bar in the package selector works well.

Installing libevent

Gearmand requires an event notification library called libevent that you cannot get as a Cygwin package, which means it has to be installed from source. You can get the source here.

Download and unpack the latest libevent stable release. At the time of this writing, I used libevent-1.4.14b-stable.
NOTE: Download and unpack to a directory that does not contain spaces in the name, such as "C:/cygwin/home/Zombat/libevent-1.4.14b-stable". If you unpack to something with spaces like "C:/Documents and Settings/Zombat/", the build process might not be able to install libevent correctly (libtool has a hard time with spaces)!
Open a Cygwin shell and cd to the unpacked libevent directory.
Run the following commands:

./configure make make install

libevent should now be installed and ready to be used when compiling the Gearman job server.

Installing the Gearman job server, gearmand.exe

Download and unpack the C implementation of gearmand from http://gearman.org/index.php?id=download
Open a cygwin shell and cd to your unpacked gearmand directory. Same rules apply as before, make sure you've unpacked in a directory with no spaces in the path! libtool hates that, and your build may fail.
Run the following commands:

./configure make make install

The Gearman job server should now be installed and ready to use! Mine was installed at /usr/local/sbin/gearmand.exe, and running it with a "triple verbose" flag (-vvv) should produce the following:

That's it for the job server. When you want to start it, simply open a Cygwin shell and run gearmand.exe. Running it with the -d flag will cause the server to run as a daemon in the background, and running with --help will show you the full option list.

Installing the Gearman Client and Worker API (Net_Gearman)

I chose to install the PEAR Client and Worker API, as it is native PHP and doesn't involve compiling PECL extensions. The PEAR package is called Net_Gearman, and was originally written by Joe Stump at Digg.com. It is old and out of date now, although there appears to be a more recent fork at http://github.com/brianlmoon/net_gearman. I stuck with the older version, as I suspect it will meet my needs, and was readily available as a PEAR package.

This also makes installation relatively painless. Assuming you've previously set PEAR up, then all you have to do is open a command window (not a Cygwin shell) and run:

pear install Net_Gearman-alpha

The "-alpha" portion is necessary, as Net_Gearman apparently never made it to a stable release version. That being said, it has functioned well for me so far. Perhaps someone will pick the project up in the future.

I'll write more about getting started with the Client and Worker API in the next article, so we can actually use Gearman to get some work done.

转自:

http://www.phpvs.net/2010/11/30/installing-gearman-and-gearmand-on-windows-with-cygwin/

��果�?/a> 2012-12-28 11:17 发表评论

Fri, 09 Nov 2012 07:56:00 GMT

aio是linux2.6以后内核实现的异步IO�Q�或者说他才是真正意义上的异步IO�?br /> epoll作�ؓselect的linux的替代品�Q�解决了selectfd_set的限制。性能优于select。而在max�q�_��上替代方案是kqueue�?br /> libevent是一个跨�q�_��异步解决�Ҏ��Q�他�Ҏ��不同的��^台提供了不同的异步方案，采用Reactor模型实现�?br /> Boost::asio是一个跨�q�_��的网�l�及底层IO的C++�~�程库，实现了对TCP、UDP、ICMP、串口的支持。对于读写方式，ASIO支持同步和异步两�U�方式。采用了epoll来实玎ͼ�插入了大量的信号处理。Asio库不需要单独便于，但是��试�q�程中对boost::system的依赖可能会需要编译部分boost中的库�?br /> muduo采用Reactor模型实现的网�l�库�Q�只支持Linux 2.6.x下的�q�发非阻塞TCP�|�络�~�程�Q�不跨��^収ͼ�不支持udp和ipv6。吞吐量斚w��muduo比libevent2�?8%�Q�在事�g处理效率�?面，muduo与libevent2��M��比较接近�Q�muduo吞吐量比boost.asio�?5%以上。性能斚w��作�ؓ解决大数据吞吐量很有优势�Q�但是对 �q�_��和网�l�协议支持方面是一个问题�?br /> ACE也是很经典的�|�络库，��《C++�|�络�~�程》作者之手，设计�_�֦��E�度堪称一��，支持协议范围也很�q�，但是使用复杂度和学习复杂度较高，一直有“学我者生�Q�用我者死”的评仗��?br /> 需要注意的是他们的定位不同�Q�aio和epoll主要是对异步提供解决�Ҏ��不是�|�络库不提供�|�络支持�Q�而libevent也是主要解决IO的问题只提供��单的http支持�Q�asio和muduo�q�有ACE一��h��高性能�|�络库�?/div>

��果�?/a> 2012-11-09 15:56 发表评论

免费的C++囑�Ş和游戏库

Fri, 15 Jun 2012 06:29:00 GMT

C++ is a multi paradigm, free form complied, general purpose and thus a very powerful language used basically forthe purpose of programming. This language is regarded as an intermediatelevel language .The main reason for this is that it consists of both high level as well aslow level features.

It is one of the most popularprogramming languages due to many reasons. It has application domains which include system software, device drivers, application software and many other including client applications and entertainment software of which the best example is a video game.

In this list we introduces some highly useful C++ graphics and game libraries. These libraries has provides a great interface to add these functionality to their project or application easily. C++ users would love to use these libraries for their next project.

Today we are going to share C++ graphic and games Libraries for developers, i hope these libraries would help developers a lot in their next project to make impressive and attractive layout for theirnest applications. Visit this list and share your thought in our comment section below.

1) Antigrain

Anti-Grain Geometry (AGG) is an Open Source, free of charge graphic library, written in industrially standard C++. The terms and conditions of use AGG are described on The License page. AGG doesn’t depend on any graphic API or technology. Basically, you can think of AGG as of a rendering engine that produces pixel images in memory from some vectorial data.

2) Amanith

AmanithVG SRE is a pure software solution that grants a superlative vector graphics quality without to sacrifice performance on any kind of architecture / platform. Thanks to its original polygon rasterization algorithm and dedicated optimized scanline fillers, this engine constitues the fastest OpenVG software rendering solution available on the market.

3) Codehead

4) Oscilloscope Lib

5) Lib SDL

Simple DirectMedia Layer is a cross-platform multimedia library designed to provide low level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used by MPEG playback software, emulators, and many popular games, including the award winning Linux port of “Civilization: Call To Power.”

6) Ogre 3d

OGRE (Object-Oriented Graphics Rendering Engine) is a scene-oriented, flexible 3D engine written in C++ designed to make it easier and more intuitive for developers to produce applications utilising hardware-accelerated 3D graphics. The class library abstracts all the details of using the underlying system libraries like Direct3D and OpenGL and provides an interface based on world objects and other intuitive classes.

转自:

http://zoomzum.com/6-free-c-graphics-and-game-libraries/

��果�?/a> 2012-06-15 14:29 发表评论

c/c++通用内存泄漏��框架GMFD(General Memory Fault Detection Framework)

Mon, 16 Jan 2012 05:03:00 GMT

1 背景�Q?/span>
       x86�q�_��有完善的用户态检��内存工��h��如valgrind�{�，可以监控�E�序�q�行中详�l�的内存信息�Q�从而精��定位内存问题。然而随着新��^台的快速诞生（比如Tilera的TilePro64 CPU)�Q�这些工具不能被及时地移植，��D��新��^台缺乏相应的手段来定位内存错误，如内存越界，泄漏�{�，而只能��用粗�_�度的方法top�Q�free �{�指令观察进�E�的动态内存总额。其�~�点是粒度太�_�，而且内存的��L��变化有很多原因引��P��在复杂的�pȝ��里，很难�_��定位内存问题的根源，甚至会漏报错报，�q�严重媄响了新��^収ͼ�如Tilera)开发与��试的效率。针对这个问题，我们提出了一个通用的新�q�_��针对c/c++内存错误��框架�?br />       该框架可适用于�Q何��^台。其通过重写标准库的内存分配和释攑և�敎ͼ�如malloc, new, new[], free,delete,delete[]�{�）, 以及�l�护一个全局的内存分配map数据�l�构实现。重写后的内存分配比如my_malloc首先调用�pȝ��malloc功能�Q�然后记录每一�ơmalloc执行�q�程中的内存操作信息�Q�包括文件名、行号以及内存尺寸，函数调用栈）�Q�以指针��gؓ key��|��存进�l�护的全局map表。而重写的my_free则是�Ҏ��传入的指针值在 map 中查扄��应的数据��ƈ��之删除�Q�而后调用�pȝ��的free ��指针所指向的内存块释放。这样当�E�序退出的时候，map 中的剩余的数据项��是我们期望��的内存泄漏信息。我们可以输出泄漏内存块的详�l�日志，比如文�g名，行号�{�等。这��大大提高类似Tilera�q�_��的内存问题追查效率，提高开发和��试的速度和质量�?/em>
2 基本原理�Q?/span>
1)   通过重写非共享内存分配释攑և�数malloc, new, new[]�Q�free,delete,delete[]截获它们在执行过�E�中的内存操作信息。重载�Ş式如下：
※   void* malloc( size_t nSize, char* pszFileName, int nLineNum )
※ void* new( size_t nSize, char* pszFileName, int nLineNum )
※ void* operator new[]( size_t nSize, char* pszFileName, int nLineNum )
※ void free( void *ptr )
※ void delete( void *ptr )
※ void operator delete[]( void *ptr )

2)   通过重写�׃�n内存分配释放函数mspace_malloc�Q�mspace_free�Q�重写�Ş式如下：

※ void* my_mspace_malloc( mspace msp,unsigned int Size, char* pszFileName, int nLineNum )
※ void my_mspace_free(mspace msp, void *ptr )

3)   我们对malloc, new, new[]�Q�mspace_malloc�q�行了重载，参数包括size_t nSize、文件名和行��P��q�里的文件名和行号就是这�ơmalloc, new, new[]�Q�mspace_malloc操作�W�被调用时所在的文�g名和行号�Q�这个信息将在发现内存泄漏时输出�Q�以帮助定位泄漏具体位置。对�?free,delete,delete[]�Q�mspace_free参数为指针地址�?br />3 实例�Q?/span>
以My_malloc, My_free��Z��Q�重写函数结构如下：

1.   在重写的my_malloc函数版本中，我们��调用malloc 的原始版本�ƈ��相应的 size_t 参数传入�Q�然后，我们��malloc的原始版本返回的指针��g��及该�ơ分配所在的文�g名和行号信息记录下来�Q�这里采用STL �?map数据�l�构存储�Q�以指针��gؓ key ��|��文�g名，行号�{�信息作��Z��个结构体是value倹{�?br />My_free重写函数�l�构如下�Q?br />

2.   当my_free 被调用时�Q�我们根据传入的指针值在 map 中找到相应的数据��ƈ��之删除�Q�而后调用 free ��指针所指向的内存块释放。这样当�E�序退出的时候，map 中的剩余的数据项��是我们企图��的内存泄漏信息�?br />4 实现关键点：
1)   如何取得内存分配代码所在的文�g名和行号�Q?/strong>
利用 C 的预�~�译�?__FILE__ �?__LINE__�Q�这两个宏将在编译时在指定位�|�展开��文�g的文件名和该行的行号
2)   利用宏定义开兛_��定走普通分支还是内存检��分支？
#if defined( MEM_DEBUG )
#define malloc DEBUG_MALLOC
#define free DEBUG_FREE
#endif
3)   何时创徏用于存储内存数据�?map 数据�l�构�Q�如何管理，何时打印内存泄漏信息�Q?/strong>
设计一个类来封装这�?map 以及对它的插入删除操作，然后构造这个类的一个全局对象�Q�appMemory�Q�，在全局对象�Q�appMemory�Q�的构造函��C��创徏�q�初始化�q�个数据�l?构，而在其析构函��C��Ҏ��据结构中剩余数据�q�行分析和输出。new 中将调用�q�个全局对象�?insert 接口��指针、文件名、行受��内存块大小�{�信息以指针��gؓ key 记录�?map 中，在delete 中调�?erase 接口��对应指针值的 map 中的数据��删除，同时�?map 的访问需要进行互斥同步，因�ؓ同一旉��可能会有多个�q�程�q�行堆上的内存操作�?br />4)   如何为非�׃�n内存甌��map�Q�如何�ؓ�׃�n内存甌��map�Q?/strong>
非共享内存的map,对于多进�E�则有多个map�Q�可按（3�Q�的�Ҏ��处理。而对于共享内存，可能A�q�程甌��到B�q�程才释放，但是每个�q�程一个map,我们��L��描这些每个map时就会出现误报的现象�Q�因此需要采取将map攑օ��׃�n内存�Ҏ��Q�我们申请一块共享内存区域�ؓmap,�q�个map对各�q�程是共享的。当�E�序中各�q�程调用�׃�n内存�Ӟ��各�q�程分配的指针及文�g名行��L��详细信息存进�q�共享的map。程序结束时�Q�扫描该�׃�n的map,��p��得到未释攄��信息。将 map攑օ��׃�n内存使用c++标准库时需要我们自己实��C��个基于共享内存的allocator�Q�替换map默认的allocator�Q�在�q�个allocator中实现map的内存分配方案。也可以使用boost库（1.35以上版本�Q�，它增加了一个叫做boost::interprocess的库�Q�具体可参考http://blog.cong.co/stl-alloc.html
5)   如何使用该工��P��
内存泄露��框架提供接口libmemck.h�Q�内容如�?/p>

在被��试�E�序里包含如下代码即可��?br />
6)   何时如何捕获信号�Q�生成leak文�g�Q?/strong>
定义一个全局的类得对象，在该�c�d��构造函数里通过signal函数捕获SIGINT、SIGABRT、SIGFPE、SIGTERM信号�Q�当捕获到这些信号其中之一�Ӟ��开始扫描map�q�将map剩余信息写入leak文�g展示�?br />7)   对��界资源的控制�Q?/strong>
�׃�n内存的各�q�程�׃�n的map�Q�各�q�程间进行读写操作需要加锁，我们�q�里采用的是信号灯实现�?br />非共享内存各个进�E�对应的map�Q�在各进�E�进行插入删除操作时也需要加锁实�?br />8)   �E�序中malloc作�ؓ函数指针�Q?/strong>
�׃��原型malloc(size)重写为my_malloc(size�Q�__FILE__,__LINE__),�q�样�׃��函数�c�d��不一��_��D��E�序调用该工��h��~�译无法通过�Q�真对这�U�情�늚�解决办法为：重写malloc(size)为my_malloc_p(size)�q�样除了文�g名和行号无法得知外，泄露的多��内存可以报出�?br />
转自http://hi.baidu.com/baiduqa/blog/item/e4c991c5ef46e5c7d10060fb.html

��果�?/a> 2012-01-16 13:03 发表评论

<�?gt;boost::any的用法、优点和�~�点以及源代码分�?

Thu, 16 Jun 2011 10:32:00 GMT

01.#include
02.#include
03.#include
04.
05.typedef std::list list_any;
06.
07.//关键部分�Q�可以存放�Q意类型的对象
08.void fill_list(list_any& la)
09.{
10.    la.push_back(10);//存放常数
11.    la.push_back( std::string("dyunze") );//存放字符串对象；注意la.push_back(“dyunze”)错误�Q�因��Z��被当错字�W�串数组
12.}
13.
14.//�Ҏ��c�d��q�行昄��
15.void show_list(list_any& la)
16.{
17.    list_any::iterator it;
18.    boost::any anyone;
19.
20.    for( it = la.begin(); it != la.end(); it++ )
21.    {
22.        anyone = *it;
23.
24.        if( anyone.type() == typeid(int) )
25.            std::cout<(*it)<26.        else if( anyone.type() == typeid(std::string) )
27.            std::cout<(*it).c_str()<28.    }
29.}
30.
31.int main()
32.{
33.    list_any la;
34.    fill_list(la);
35.    show_list(la);
36.
37.    return 0;
38.}
#include
#include
#include

typedef std::list list_any;

//关键部分�Q�可以存放�Q意类型的对象
void fill_list(list_any& la)
{
    la.push_back(10);//存放常数
    la.push_back( std::string("dyunze") );//存放字符串对象；注意la.push_back(“dyunze”)错误�Q�因��Z��被当错字�W�串数组
}

//�Ҏ��c�d��q�行昄��
void show_list(list_any& la)
{
    list_any::iterator it;
    boost::any anyone;

    for( it = la.begin(); it != la.end(); it++ )
    {
        anyone = *it;

        if( anyone.type() == typeid(int) )
            std::cout<(*it)<        else if( anyone.type() == typeid(std::string) )
            std::cout<(*it).c_str()<    }
}

int main()
{
    list_any la;
    fill_list(la);
    show_list(la);

    return 0;
}

boost::any的优点：

     对设计模式理解的朋友都会知道合成模式。因为多态只有在使用指针或引用的情况下才能显玎ͼ�所以std容器中只能存放指针或引用�Q�但实际上只能存放指针，无法存放引用�Q�这个好像是c++的不��_��Q�。如�Q?br />
     std::list mylist;

�q�样�Q�我们就要对指针所指向内容的生存周期操�?可能需要程序员适时删除甌��的内存；但是�׃��存放指针�Q�插�?删除的效率高)�Q�而��用boost::any��可能避免这�U�情况，因�ؓ我们可以存放�c�d��本��n�Q�当然存放指针也可以�Q�。这是boost::any的优点之一�?br />
    boost::any另一个优�Ҏ��可以存放��M��c�d��。而前面提到的mylist只能存放BaseClass�c�L��针以及其�l�承�cȝ��指针�?br />
boost::any的缺点：

    �׃��boost::any可以存放��M��c�d��Q�自然它用不了多态特性，没有�l�一的接口，所以在获取容器中的元素旉��要实现判别元素的真正�c�d��Q�这增加了程序员的负担。与面向对象�~�程思想有些矛盾�Q�但整个标准c++模板库何��不是如此，用那些牛人的话来��_��?#8220;有益补充”�?br />
   ��M��Q�有利必有弊�Q�没有十全十��的�?br />


分析�q�模仿boost::any�Q?br />
     ��M��一下boost::any的源代码�Q��ƈ模仿一下其实现(相当一部分时拷贝原代码)�Q�下面是代码(只包含必要功�?�?br />
实现any的功能主要由三部分组成：
1�Q�any�c?br />2�Q�真正保存数据的holder�c�d��其基�c�placeholder
3�Q�获取真正数据的模板函数any_cast�Q�类型�{换的功能�?br />
view plaincopy to clipboardprint?
01.#include
02.#include
03.#include
04.
05.//自定义的any�c?nbsp;
06.class any
07.{
08.public:
09.
10.    //保存真正数据的接口类
11.    class placeholder
12.    {
13.    public:
14.        virtual ~placeholder()
15.        {
16.        }
17.    public:
18.
19.        virtual const std::type_info & type() const = 0;
20.        virtual placeholder * clone() const = 0;
21.    };
22.
23.    //真正保存和获取数据的�c�R�?nbsp;
24.    template
25.    class holder : public placeholder
26.    {
27.    public:
28.        holder(const ValueType & value): held(value)
29.        {
30.        }
31.
32.    public:
33.
34.        virtual const std::type_info & type() const
35.        {
36.            return typeid(ValueType);
37.        }
38.
39.        virtual placeholder * clone() const
40.        {
41.            return new holder(held);//使用了原型模�?nbsp;
42.        }
43.
44.    public:
45.
46.        //真正的数据，��׃��存在�q�里
47.        ValueType held;
48.    };
49.
50.public:
51.
52.    any(): content(NULL)
53.    {
54.    }
55.
56.    //模板构造函敎ͼ�参数可以是�Q意类型，真正的数据保存在content�?nbsp;
57.    template
58.    any(const ValueType & value): content(new holder(value))
59.    {
60.    }
61.
62.    //拯��构造函�?nbsp;
63.    any(const any & other)
64.        : content(other.content ? other.content->clone() : 0)
65.    {
66.    }
67.
68.    //析构函数�Q�删除保存数据的content对象
69.    ~any()
70.    {
71.        if(NULL != content)
72.            delete content;
73.    }
74.
75.private:
76.    //一个placeholde对象指针�Q�指向其子类folder的一个实�?nbsp;
77.    // 即content( new holder(value) )语句
78.    placeholder* content;
79.
80.    template friend ValueType any_cast(const any& operand);
81.public:
82.
83.    //查询真实数据的类型�?nbsp;
84.    const std::type_info & type() const
85.    {
86.        return content ? content->type() : typeid(void);
87.    }
88.};
89.
90.
91.//获取content->helder数据的方法。用来获取真正的数据
92.template
93.ValueType any_cast(const any& operand)
94.{
95.    assert( operand.type() == typeid(ValueType) );
96.    return static_cast *>(operand.content)->held;
97.}
98.
99.//下代码是使用�C�Z��
100.
101.typedef std::list list_any;
102.
103.void fill_list(list_any& la)
104.{
105.    la.push_back(10);//存放常数�Q�调用了any的模板构造函敎ͼ�下同
106.    la.push_back( std::string("我是string") );//存放字符串对象；注意la.push_back(“dyunze”)错误�Q�因��Z��被当错字�W�串数组
107.
108.    char* p = "我是帔R��区字�W�串abc";
109.    la.push_back(p);//可以存放指针�Q�但要注意指针的失效问题
110.}
111.
112.//�Ҏ��c�d��q�行昄��
113.void show_list(list_any& la)
114.{
115.    list_any::iterator it;
116.
117.    for( it = la.begin(); it != la.end(); it++ )
118.    {
119.
120.        if( (*it).type() == typeid(int) )
121.            std::cout<(*it)<122.        else if( (*it).type() == typeid(std::string) )
123.            std::cout<(*it).c_str()<124.        else if( (*it).type() == typeid(char*) )
125.            std::cout<(*it)<126.    }
127.}
128.
129.int main()
130.{
131.    list_any la;
132.    fill_list(la);
133.    show_list(la);
134.
135.    return 0;
136.}

boost::any是一个很有趣的类�Q�刚刚开始我�q�以为其��是一个variant�c�d��Q?br />能够��Q意类型��g��存进去，能够以�Q意类型��D��出来�Q�不�q�我错了 :(
  boost::any的作者认为，所谓generic type有三个层面的解释�Ҏ��Q?br />  1.�c�M��variant�c�d��那样��L��q�行�c�d��转换�Q�可以保存一�?int)5�q�去�Q?br />    ��M��?string)"5"出来。Win下面的VARIANT�c�d��是以一个巨大的
    union实现的类似功能，使用灉|��但效率较�?br />  2.区别对待包含值的�c�d��Q�保存一�?int)5�q�去�Q�不会被隐式转换�?br />    (string)'5'或�?double)5.0�Q�这��h��率较高且�c�d��安全�Q?br />    不必担心ambiguous conversions
  3.对包含值类型不加区别，例如把所有保存的值强制�{换�ؓvoid *保存
    ��d��时再有程序员判断其类型。这��h��率虽最高但无法保证�c�d��安全
  boost::any��选择了第二层面的设计思�\�Q�它允许用户��Q意类型��g��?br />�q�一个any�c�d��变量�Q�但内部�q�不改变值的�c�d��Q��ƈ提供�Ҏ��让用户在使用�?br />��d��/被动�q�行�c�d��判断�?br />
  在实现方面，boost::any使用两层内部�c�placeholder和holder保存
实际�c�d��的倹{��类placeholder只是一个接口，模板�c�holder是特定类�?br />的实现。其中type()�Ҏ��获取实际值类型，即typeid(ValueType);
clone()�Ҏ��获取值的拯��return new holder(held);
  virtual const std::type_info & type() const
  virtual placeholder * clone() const
  其值的�c�d��信息不象Win的VARIANT那样以专门的字段保存�Q?br />而是通过模板参数形式静态保存。这��h��率更高（仅在�~�译期）�Q?br />
通用性更强（��M��c�d��都可以，真正any�Q�但灉|��性不如VARIANT
  在进行拷贝构�?赋�?swap�Ӟ��都直接将整个placeholder换掉�Q?br />�q�样可以保证值类型的延箋性�?br />
  在��用方面，提供了主�?被动�q�行�c�d��的�Ҏ��?br />  可以使用any::type()�Ҏ��d��值类�?br />bool is_int(const boost::any & operand)
{
    return operand.type() == typeid(int);
}
  也可以通过any_cast函数被动�q�行��。此函数与C++中的*_cast
�p�d��关键字有相同的语法规范，��试�q�行�c�d��转换�Q�如�c�d��不匹配则�?br />指针转换�q�回NULL�Q�对引用转换抛出boost::bad_any_cast异常
  boost::any str = string("12345");
  try
  {
    cout << boost::any_cast(str) << endl;
  }
  catch(boost::bad_any_cast e)
  {
    cerr << e.what() << endl;
  }

  在应用方面，any�c�d��适合于类型不同但使用相关的倹{��如C++�?..
形式的函数参数本事不是类型安全的�Q�可以通过vector攚w��之
然后在��用时��类型是否匹配，如可攚w��printf�?br />  void safe_printf(const char *format, const vector& params)
  {
    int index = 0;
    for(const char *pch = format; *pch; pch++)
    {
      switch(*pch)
      {
        case '%':
        {
          switch(*++pch)
          {
            case 'i':
            case 'd':
            {
              if(params[index].type() == typeid(int) ||
                 params[index].type() == typeid(short))
              {
                ...
              }
              else
                throw ...
            }
          }
        }
        case '\':
        {
          ...
        }
        default:
        {
          putchar(*pch);
        }
      }
    }
  }

附：boost::any.hpp
#ifndef BOOST_ANY_INCLUDED
#define BOOST_ANY_INCLUDED

// what:  variant type boost::any
// who:   contributed by Kevlin Henney,
//        with features contributed and bugs found by
//        Ed Brey, Mark Rodgers, Peter Dimov, and James Curran
// when:  July 2001
// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95

#include
#include

#include "boost/config.hpp"

namespace boost
{
    class any
    {
    public: // structors

        any()
          : content(0)
        {
        }

        template
        any(const ValueType & value)
          : content(new holder(value))
        {
        }

        any(const any & other)
          : content(other.content ? other.content->clone() : 0)
        {
        }

        ~any()
        {
            delete content;
        }

    public: // modifiers

        any & swap(any & rhs)
        {
            std::swap(content, rhs.content);
            return *this;
        }

        template
        any & operator=(const ValueType & rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }

        any & operator=(const any & rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }

    public: // queries

        bool empty() const
        {
            return !content;
        }

        const std::type_info & type() const
        {
            return content ? content->type() : typeid(void);
        }

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
    private: // types
#else
    public: // types (public so any_cast can be non-friend)
#endif

        class placeholder
        {
        public: // structors

            virtual ~placeholder()
            {
            }

        public: // queries

            virtual const std::type_info & type() const = 0;

            virtual placeholder * clone() const = 0;

        };

        template
        class holder : public placeholder
        {
        public: // structors

            holder(const ValueType & value)
              : held(value)
            {
            }

        public: // queries

            virtual const std::type_info & type() const
            {
                return typeid(ValueType);
            }

            virtual placeholder * clone() const
            {

                return new holder(held);
            }

        public: // representation

            ValueType held;

        };

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

    private: // representation

        template
        friend ValueType * any_cast(any *);

#else

    public: // representation (public so any_cast can be non-friend)

#endif

        placeholder * content;

    };

    class bad_any_cast : public std::bad_cast
    {
    public:
        virtual const char * what() const throw()
        {
            return "boost::bad_any_cast: "
                   "failed conversion using boost::any_cast";
        }
    };

    template
    ValueType * any_cast(any * operand)
    {
        return operand && operand->type() == typeid(ValueType)
                    ? &static_cast *>(operand->content)->held
                    : 0;
    }

    template
    const ValueType * any_cast(const any * operand)
    {
        return any_cast(const_cast(operand));
    }

    template
    ValueType any_cast(const any & operand)
    {
        const ValueType * result = any_cast(&operand);
        if(!result)
            throw bad_any_cast();
        return *result;
    }

}

// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose is hereby granted without fee, provided that this copyright and
// permissions notice appear in all copies and derivatives.
//
// This software is provided "as is" without express or implied warranty.

#endif

��果�?/a> 2011-06-16 18:32 发表评论

Tue, 05 Apr 2011 12:18:00 GMT

引言

本书主要针对的是 C++ �E�序的性能优化�Q�深入介�l?C++ �E�序性能优化的方法和实例。全书由 4 个篇�l�成�Q�第 1 ��介�l?C++ 语言的对象模型，该篇是优�?C++ �E�序的基��Q�第 2 ��主要针对如何优�?C++ �E�序的内存��用；�W?3 ��介�l�如何优化程序的启动性能�Q�第 4 ��介�l�了三类性能优化工具�Q�即内存分析工具、性能分析工具�?I/O ��工��P��它们是测量程序性能的利器�?/p>
本章首先��单介�l�自定义内存池性能优化的原理，然后列�D软�g开发中常用的内存池的不同类型，�q�给出具体实现的实例�?/p>

回页�?/font>

6.1 自定义内存池性能优化的原�?/span>

书名�Q?/strong>《C++应用�E�序性能优化�?
作者：冯宏华、徐莏V��程�q�、汪��?�{�编�?
出版�C�：电子工业出版�C?
出版日期�Q?/strong>2007 �q?03 �?
ISBN�Q?/strong>978-7-121-03831-0
购买�Q?/strong> 中国互动出版�|?/font>�?a >dearbook

推荐章节:

前言 �?目录

�W?2 章：C++ 语言�Ҏ��的性能分析

�W?6 章：内存�?/font>

更多推荐书籍�Q�请讉K�� developerWorks 图书频道�?/p>
�Ƣ迎您对本书提出宝贵的反馈意见。您可以通过本页面最下方�?�� 栏目为本文打分，�q�反馈您的徏议和意见�?/p>
如果您对 developerWorks 图书频道有什么好的徏议，�Ƣ迎您将��发给我们�?/p>

如前所�q�ͼ�读者已�l�了解到"�?�?�?的区别。而在�~�程实践中，不可避免地要大量用到堆上的内存。例如在�E�序中维护一个链表的数据�l�构�Ӟ��每次新增或者删除一个链表的节点�Q�都需要从内存堆上分配或者释放一定的内存�Q�在�l�护一个动态数�l�时�Q�如果动态数�l�的大小不能满��E�序需要时�Q�也要在内存堆上分配新的内存�I�间�?/p>
6.1.1 默认内存��理函数的不��?/span>

利用默认的内存管理函数new/delete或malloc/free在堆上分配和释放内存会有一些额外的开销�?/p>
�pȝ��在接收到分配一定大��内存的��h��Ӟ��首先查找内部�l�护的内存空闲块表，�q�且需要根据一定的��法�Q�例如分配最先找到的不小于申请大��的内存块给��h��者，或者分配最适于甌��大小的内存块�Q�或者分配最大空闲的内存块等�Q�找到合适大��的�I�闲内存块。如果该�I�闲内存块过大，�q�需要切割成已分配的部分和较��的�I�闲块。然后系�l�更新内存空闲块表，完成一�ơ内存分配。类似地�Q�在释放内存�Ӟ��pȝ��把释攄��内存块重新加入到�I�闲内存块表中。如果有可能的话�Q�可以把盔R��的空闲块合�ƈ成较大的�I�闲块�?/p>
默认的内存管理函数还考虑到多�U�程的应用，需要在每次分配和释攑ֆ�存时加锁�Q�同样增加了开销�?/p>
可见�Q�如果应用程序频�J�地在堆上分配和释放内存�Q�则会导致性能的损失。�ƈ且会使系�l�中出现大量的内存碎片，降低内存的利用率�?/p>
默认的分配和释放内存��法自然也考虑了性能�Q�然而这些内存管理算法的通用版本��Z��应付更复杂、更�q�泛的情况，需要做更多的额外工作。而对于某一个具体的应用�E�序来说�Q�适合自��n特定的内存分配释放模式的自定义内存池则可以获得更好的性能�?/p>
6.1.2 内存池的定义和分�c?/span>

自定义内存池的思想通过�q�个"�?字表露无疑，应用�E�序可以通过�pȝ��的内存分配调用预先一�ơ性申请适当大小的内存作��Z��个内存池�Q�之后应用程序自己对内存的分配和释放则可以通过�q�个内存池来完成。只有当内存池大��需要动态扩展时�Q�才需要再调用�pȝ��的内存分配函敎ͼ�其他旉��对内存的一切操作都在应用程序的掌控之中�?/p>
应用�E�序自定义的内存池根据不同的适用场景又有不同的类型�?/p>
从线�E�安全的角度来分�Q�内存池可以分�ؓ单线�E�内存池和多�U�程内存池。单�U�程内存池整个生命周期只被一个线�E��用，因而不需要考虑互斥讉K��的问题；多线�E�内存池有可能被多个�U�程�׃�n�Q�因此则需要在每次分配和释攑ֆ�存时加锁。相对而言�Q�单�U�程内存池性能更高�Q�而多�U�程内存池适用范围更广�?/p>
从内存池可分配内存单元大��来分，可以分�ؓ固定内存池和可变内存池。所谓固定内存池是指应用�E�序每次从内存池中分配出来的内存单元大小事先已经��定�Q�是固定不变的；而可变内存池则每�ơ分配的内存单元大小可以按需变化�Q�应用范围更�q�，而性能比固定内存池要低�?/p>
6.1.3 内存池工作原理示�?/span>

下面以固定内存池��Z��说明内存池的工作原理�Q�如�?-1所�C��?/p>
�?-1 固定内存�?/strong>

固定内存池由一�p�d��固定大小的内存块�l�成�Q�每一个内存块又包含了固定数量和大��的内存单元�?/p>
如图6-1所�C�，该内存池一共包�?个内存块。在内存池初�ơ生成时�Q�只向系�l�申请了一个内存块�Q�返回的指针作�ؓ整个内存池的头指针。之后随着应用�E�序对内存的不断需求，内存池判断需要动态扩大时�Q�才再次向系�l�申��h��的内存块�Q��ƈ把所有这些内存块通过指针链接��h��。对于操作系�l�来��_��它已�l��ؓ该应用程序分配了4个等大小的内存块。由于是大小固定的，所以分配的速度比较快；而对于应用程序来��_��其内存池开辟了一定大��，内存池内部却�q�有剩余的空间�?/p>
例如攑֤�来看�W?个内存块�Q�其中包含一部分内存池块头信息和3个大��相�{�的内存池单元。单�?和单�?是空闲的�Q�单�?已经分配。当应用�E�序需要通过该内存池分配一个单元大��的内存�Ӟ��只需要简单遍历所有的内存池块头信息，快速定位到�q�有�I�闲单元的那个内存池块。然后根据该块的块头信息直接定位到第1个空闲的单元地址�Q�把�q�个地址�q�回�Q��ƈ且标��C��一个空闲单元即可；当应用程序释放某一个内存池单元�Ӟ��直接在对应的内存池块头信息中标记该内存单元�ؓ�I�闲单元卛_��?/p>
可见与系�l�管理内存相比，内存池的操作非常�q�速，它在性能优化斚w��的优点主要如下�?/p>
�Q?�Q�针对特�D�情况，例如需要频�J�分配释攑֛�定大��的内存对象�Ӟ��不需要复杂的分配��法和多�U�程保护。也不需要维护内存空闲表的额外开销�Q�从而获得较高的性能�?/p>
�Q?�Q�由于开辟一定数量的�q�箋内存�I�间作�ؓ内存池块�Q�因而一定程度上提高了程序局部性，提升了程序性能�?/p>
�Q?�Q�比较容易控刉��边界寚w��和内存字节对齐，没有内存��片的问题�?/p>

回页�?/font>

6.2 一个内存池的实现实�?/span>

本节分析在某个大型应用程序实际应用到的一个内存池实现�Q��ƈ详细讲解其��用方法与工作原理。这是一个应用于单线�E�环境且分配单元大小固定的内存池�Q�一般用来�ؓ执行时会动态频�J�地创徏且可能会被多�ơ创建的�c�d��象或者结构体分配内存�?/p>
本节首先讲解该内存池的数据结构声明及囄��Q�接着描述其原理及行�ؓ特征。然后逐一讲解实现�l�节�Q�最后介�l�如何在实际�E�序中应用此内存池，�q�与使用普通内存函数申请内存的�E�序性能作比较�?/p>
6.2.1 内部构�?/span>

内存池类MemoryPool的声明如下：

class MemoryPool { private: MemoryBlock* pBlock; USHORT nUnitSize; USHORT nInitSize; USHORT nGrowSize; public: MemoryPool( USHORT nUnitSize, USHORT nInitSize = 1024, USHORT nGrowSize = 256 ); ~MemoryPool(); void* Alloc(); void Free( void* p ); };

MemoryBlock为内存池中附着在真正用来�ؓ内存��h��分配内存的内存块头部的结构体�Q�它描述了与之联�pȝ��内存块的使用信息�Q?/p>

struct MemoryBlock { USHORT nSize; USHORT nFree; USHORT nFirst; USHORT nDummyAlign1; MemoryBlock* pNext; char aData[1]; static void* operator new(size_t, USHORT nTypes, USHORT nUnitSize) { return ::operator new(sizeof(MemoryBlock) + nTypes * nUnitSize); } static void operator delete(void *p, size_t) { ::operator delete (p); } MemoryBlock (USHORT nTypes = 1, USHORT nUnitSize = 0); ~MemoryBlock() {} };

此内存池的数据结构如�?-2所�C��?/p>
�?-2 内存池的数据�l�构

6.2.2 ��M��机制

此内存池的��M��机制如下�?/p>
�Q?�Q�在�q�行�q�程中，MemoryPool内存池可能会有多个用来满��_��存申误��求的内存块，�q�些内存块是从进�E�堆中开辟的一个较大的�q�箋内存区域�Q�它�׃��个MemoryBlock�l�构体和多个可供分配的内存单元组成，所有内存块�l�成了一个内存块链表�Q�MemoryPool 的pBlock是这个链表的头。对每个内存块，都可以通过其头部的MemoryBlock�l�构体的pNext成员讉K��紧跟在其后面的那个内存块�?/p>
�Q?�Q�每个内存块�׃��部分�l�成�Q�即一个MemoryBlock�l�构体和多个内存分配单元。这些内存分配单元大��固定（�?MemoryPool的nUnitSize表示�Q�，MemoryBlock�l�构体�ƈ不维护那些已�l�分配的单元的信息；相反�Q�它只维护没有分配的自由分配单元的信息。它有两个成员比较重要：nFree和nFirst。nFree记录�q�个内存块中�q�有多少个自由分配单元，而nFirst则记录下一个可供分配的单元的编受��每一个自由分配单元的头两个字节（即一个USHORT型��|��记录了紧跟它之后的下一个自由分配单元的�~�号�Q�这��P��通过利用每个自由分配单元的头两个字节�Q�一个MemoryBlock中的所有自由分配单元被链接��h��?/p>
�Q?�Q�当有新的内存请求到来时�Q�MemoryPool会通过pBlock遍历MemoryBlock链表�Q�直到找到某�?MemoryBlock所在的内存块，其中�q�有自由分配单元�Q�通过��MemoryBlock�l�构体的nFree成员是否大于0�Q�。如果找到这��L��内存块，取得其MemoryBlock的nFirst��|��此�ؓ该内存块中第1个可供分配的自由单元的编��P��。然后根据这个编号定位到该自由分配单元的起始位置�Q�因为所有分配单元大��固定，因此每个分配单元的�v始位�|�都可以通过�~�号分配单元大小来偏�U�d��位）�Q�这个位�|�就是用来满��x��ơ内存申误��求的内存的�v始地址。但在返回这个地址前，需要首先将该位�|�开始的头两个字节的��|��q�两个字节��D��录其之后的下一个自由分配单元的�~�号�Q�赋�l�本内存块的 MemoryBlock的nFirst成员。这样下一�ơ的��h��׃��用这个编号对应的内存单元来满��I��同时��此内存块的MemoryBlock的nFree 递减1�Q�然后才��刚才定位到的内存单元的起始位置作�ؓ此次内存��h��的返回地址�q�回�l�调用者�?/p>
�Q?�Q�如果从现有的内存块中找不到一个自��q��内存分配单元�Q�当�W?�ơ请求内存，以及现有的所有内存块中的所有内存分配单元都已经被分配时会发生这�U�情形）�Q�MemoryPool��׃��从进�E�堆中申请一个内存块�Q�这个内存块包括一个MemoryBlock�l�构体，及紧��d��后的多个内存分配单元�Q�假讑ֆ�存分配单元的个数为n�Q�n可以取值MemoryPool中的nInitSize或者nGrowSize�Q�，甌��完后�Q��ƈ不会立刻��其中的一个分配单元分配出去，而是需要首先初始化�q�个内存块。初始化的操作包括设�|�MemoryBlock的nSize为所有内存分配单元的大小�Q�注意，�q�不包括MemoryBlock�l�构体的大小�Q�、nFree为n-1�Q�注意，�q�里是n-1而不是n�Q�因为此�ơ新内存块就是�ؓ了满��一�ơ新的内存请求而申��L��Q�马上就会分配一块自由存储单元出去，如果设�ؓn-1�Q�分配一个自由存储单元后无须再将n递减1�Q�，nFirst�?�Q�已�l�知道nFirst��Z��一个可以分配的自由存储单元的编受��ؓ1的原因与nFree为n-1相同�Q�即立即会将�~�号�?的自由分配单元分配出厅R��现在设�?�Q�其后不用修改nFirst的��|��Q�MemoryBlock的构造需要做更重要的事情�Q�即��编号�ؓ0的分配单元之后的所有自由分配单元链接�v来。如前所�q�ͼ�每个自由分配单元的头两个字节用来存储下一个自由分配单元的�~�号。另外，因�ؓ每个分配单元大小固定�Q�所以可以通过其编号和单元大小�Q�MemoryPool的nUnitSize成员�Q�的乘积作�ؓ偏移��D��行定位。现在唯一的问题是定位从哪个地址开始？�{�案是MemoryBlock的aData[1]成员开始。因为aData[1]实际上是属于MemoryBlock�l�构体的�Q�MemoryBlock�l�构体的最后一个字节）�Q�所以实质上�Q�MemoryBlock�l�构体的最后一个字节也用做被分配出�ȝ��分配单元的一部分。因为整个内存块由MemoryBlock�l�构体和整数个分配单元组成，�q�意味着内存块的最后一个字节会被浪费，�q�个字节在图6-2中用位于两个内存的最后部分的��黑背景的小块标识。确定了分配单元的�v始位�|�后�Q�将自由分配单元链接��h��的工作就很容易了。即从aData位置开始，每隔nUnitSize大小取其头两个字节，记录其之后的自由分配单元的编受��因为刚开始所有分配单元都是自��q��Q�所以这个编号就是自�w�编号加1�Q�即位置上紧跟其后的单元的编受��初始化后，��此内存块的�W?个分配单元的起始地址�q�回�Q�已�l�知道这个地址��是aData�?/p>
�Q?�Q�当某个被分配的单元因�ؓdelete需要回收时�Q�该单元�q�不会返回给�q�程堆，而是�q�回�l�MemoryPool。返回时�Q�MemoryPool能够知道该单元的起始地址。这�Ӟ��MemoryPool开始遍历其所�l�护的内存块链表�Q�判断该单元的�v始地址是否落在某个内存块的地址范围内。如果不在所有内存地址范围内，则这个被回收的单元不属于�q�个MemoryPool�Q�如果在某个内存块的地址范围内，那么它会��这个刚刚回收的分配单元加到�q�个内存块的MemoryBlock所�l�护的自由分配单元链表的头部�Q�同时将其nFree值递增1。回收后�Q�考虑到资源的有效利用及后�l�操作的性能�Q�内存池的操作会�l�箋判断�Q�如果此内存块的所有分配单元都是自��q��Q�那么这个内存块��׃��从MemoryPool中被�U�d��q�作��Z��个整体返回给�q�程堆；如果该内存块中还有非自由分配单元�Q�这时不能将此内存块�q�回�l�进�E�堆。但是因为刚刚有一个分配单元返回给了这个内存块�Q�即�q�个内存块有自由分配单元可供下次分配�Q�因此它会被�U�d��MemoryPool�l�护的内存块的头部。这样下�ơ的内存��h��到来�Q�MemoryPool遍历其内存块链表以寻找自由分配单元时�Q�第1�ơ寻扑ְ�会找到这个内存块。因��个内存块��实有自由分配单元，�q�样可以减少MemoryPool的遍历次数�?/p>
�l�g��所�q�ͼ�每个内存池（MemoryPool�Q�维护一个内存块链表�Q�单链表�Q�，每个内存块由一个维护该内存块信息的块头�l�构�Q�MemoryBlock�Q�和多个分配单元�l�成�Q�块头结构MemoryBlock则进一步维护一个该内存块的所有自由分配单元组成的"链表"。这个链表不是通过"指向下一个自由分配单元的指针"链接��h��的，而是通过"下一个自由分配单元的�~�号"链接��h��Q�这个编号值存储在该自由分配单元的头两个字节中。另外，�W?个自由分配单元的起始位置�q�不是MemoryBlock�l�构�?后面�?�W?个地址位置�Q�而是MemoryBlock�l�构�?内部"的最后一个字节aData�Q�也可能不是最后一个，因�ؓ考虑到字节对齐的问题�Q�，卛_��配单元实际上往前面错了一位。又因�ؓMemoryBlock�l�构体后面的�I�间刚好是分配单元的整数倍，�q�样依次错位下去�Q�内存块的最后一个字节实际没有被利用。这么做的一个原因也是考虑��C��同��^台的�U�L��问题�Q�因��Z��同��^台的寚w��方式可能不尽相同。即当申请MemoryBlock大小内存�Ӟ��可能会返回比其所有成员大��d��q�要大一些的内存。最后的几个字节是�ؓ�?补齐"�Q�而��?aData成�ؓ�W?个分配单元的起始位置�Q�这样在寚w��方式不同的各�U��^��C��都可以工作�?/p>
6.2.3 �l�节剖析

有了上述的��M��印象后，本节来仔�l�剖析其实现�l�节�?/p>
�Q?�Q�MemoryPool的构造如下：

MemoryPool::MemoryPool( USHORT _nUnitSize, USHORT _nInitSize, USHORT _nGrowSize ) { pBlock = NULL; �? nInitSize = _nInitSize; �? nGrowSize = _nGrowSize; �? if ( _nUnitSize > 4 ) nUnitSize = (_nUnitSize + (MEMPOOL_ALIGNMENT-1)) & ~(MEMPOOL_ALIGNMENT-1); �? else if ( _nUnitSize <= 2 ) nUnitSize = 2; �? else nUnitSize = 4; }

从①处可以看出，MemoryPool创徏�Ӟ��q�没有立��d��建真正用来满��_��存申��L��内存块，卛_��存块链表刚开始时为空�?/p>
②处和③处分别设�|?�W?�ơ创建的内存块所包含的分配单元的个数"�Q�及"随后创徏的内存块所包含的分配单元的个数"�Q�这两个值在MemoryPool创徏旉��过参数指定�Q�其后在该MemoryPool对象生命周期中一直不变�?/p>
后面的代码用来设�|�nUnitSize�Q�这个值参考传入的_nUnitSize参数。但是还需要考虑两个因素。如前所�q�ͼ�每个分配单元在自��q��态时�Q�其头两个字节用来存�?其下一个自由分配单元的�~�号"。即每个分配单元"最��?�?两个字节"�Q�这��是⑤处赋值的原因。④处是��大�?个字节的大小_nUnitSize往�?取整�?大于_nUnitSize的最��的MEMPOOL_ ALIGNMENT的倍数�Q�前提是MEMPOOL_ALIGNMENT�?的倍数�Q�。如_nUnitSize�?1 �Ӟ��MEMPOOL_ALIGNMENT�?�Q�nUnitSize�?6�Q�MEMPOOL_ALIGNMENT�?�Q�nUnitSize�?12�Q�MEMPOOL_ALIGNMENT�?�Q�nUnitSize�?2�Q�依�ơ类推�?/p>
�Q?�Q�当向MemoryPool提出内存��h��Ӟ��

void* MemoryPool::Alloc() { if ( !pBlock ) �? { …… } MemoryBlock* pMyBlock = pBlock; while (pMyBlock && !pMyBlock->nFree )�? pMyBlock = pMyBlock->pNext; if ( pMyBlock ) �? { char* pFree = pMyBlock->aData+(pMyBlock->nFirst*nUnitSize); pMyBlock->nFirst = *((USHORT*)pFree); pMyBlock->nFree--; return (void*)pFree; } else �? { if ( !nGrowSize ) return NULL; pMyBlock = new(nGrowSize, nUnitSize) FixedMemBlock(nGrowSize, nUnitSize); if ( !pMyBlock ) return NULL; pMyBlock->pNext = pBlock; pBlock = pMyBlock; return (void*)(pMyBlock->aData); } }

MemoryPool满��内存��h��的步骤主要由四步�l�成�?/p>
①处首先判断内存池当前内存块链表是否为空�Q�如果�ؓ�I�，则意味着�q�是�W?�ơ内存申误��求。这�Ӟ��从进�E�堆中申请一个分配单元个��CؓnInitSize的内存块�Q��ƈ初始化该内存块（主要初始化MemoryBlock�l�构体成员，以及创徏初始的自由分配单元链表，下面会详�l�分析其代码�Q�。如果该内存块申��h��功，�q�初始化完毕�Q�返回第1个分配单元给调用函数。第1个分配单元以MemoryBlock�l�构体内的最后一个字节�ؓ起始地址�?/p>
②处的作用是当内存池中已有内存块�Q�即内存块链表不为空�Q�时遍历该内存块链表�Q�寻找还�?自由分配单元"的内存块�?/p>
③处��查如果找到还有自由分配单元的内存块，�?定位"到该内存块现在可以用的自由分配单元处�?定位"�?MemoryBlock�l�构体内的最后一个字节位�|�aData��v始位�|�，以MemoryPool的nUnitSize为步长来�q�行。找到后�Q�需要修�?MemoryBlock的nFree信息�Q�剩下来的自由分配单元比原来减少了一个）�Q�以及修�Ҏ��内存块的自由存储单元链表的信息。在扑ֈ�的内存块中，pMyBlock->nFirst��内存块中自由存储单元链表的表��_��其下一个自由存储单元的�~�号存放�?pMyBlock->nFirst指示的自由存储单元（亦即刚才定位到的自由存储单元�Q�的头两个字节。通过刚才定位到的位置�Q�取其头两个字节的��|��赋给pMyBlock->nFirst�Q�这��是此内存块的自由存储单元链表的新的表头�Q�即下一�ơ分配出�ȝ��自由分配单元的编��P��如果nFree大于零的话）。修改维护信息后�Q�就可以��刚才定位到的自由分配单元的地址�q�回�l�此�ơ申��L��调用函数。注意，因�ؓ�q�个分配单元已经被分配，而内存块无须�l�护已分配的分配单元�Q�因此该分配单元的头两个字节的信息已�l�没有用处。换个角度看�Q�这个自由分配单元返回给调用函数后，调用函数如何处置�q�块内存�Q�内存池无从知晓�Q�也无须知晓。此分配单元在返回给调用函数�Ӟ��其内容对于调用函数来说是无意义的。因此几乎可以肯定调用函数在用这个单元的内存时会覆盖其原来的内容�Q�即头两个字节的内容也会被抹厅R��因此每个存储单元�ƈ没有因�ؓ需要链接而引入多余的�l�护信息�Q�而是直接利用单元内的头两个字节，当其分配后，头两个字节也可以被调用函数利用。而在自由状态时�Q�则用来存放�l�护信息�Q�即下一个自由分配单元的�~�号�Q�这是一个有效利用内存的好例子�?/p>
④处表示在②处遍历时�Q�没有找到还有自由分配单元的内存块，�q�时�Q�需要重新向�q�程堆申请一个内存块。因��Z��是第一�ơ申请内存块�Q�所以申��L��内存块包含的分配单元个数为nGrowSize�Q�而不再是nInitSize。与①处相同�Q�先做这个新甌��内存块的初始化工作，然后��此内存块插入MemoryPool的内存块链表的头部，再将此内存块的第1个分配单元返回给调用函数。将此新内存块插入内存块链表的头部的原因是该内存块还有很多可供分配的自由分配单元�Q�除非nGrowSize�{�于1�Q�这应该不太可能。因为内存池的含义就是一�ơ性地从进�E�堆中申请一大块内存�Q�以供后�l�的多次甌��Q�，攑֜�头部可以使得在下�ơ收到内存申��h��Q�减��②处对内存块的遍历旉��?/p>
可以用图6-2的MemoryPool来展�C�MemoryPool::Alloc的过�E�。图6-3是某个时刻MemoryPool的内部状态�?/p>
�?-3 某个时刻MemoryPool的内部状�?/strong>

因�ؓMemoryPool的内存块链表不�ؓ�I�，因此会遍历其内存块链表。又因�ؓ�W?个内存块里有自由的分配单元，所以会从第1个内存块中分配。检查nFirst�Q�其��gؓm�Q�这时pBlock->aData+(pBlock->nFirst*nUnitSize) 定位到编号�ؓm的自由分配单元的起始位置�Q�用pFree表示�Q�。在�q�回pFree之前�Q�需要修�Ҏ��内存块的�l�护信息。首先将nFree递减1�Q�然后取�?pFree处开始的头两个字节的��|��需要说明的是，�q�里aData处��gؓk。其实不是这一个字节。而是以aData和紧跟其后的另外一个字节合在一��h��成的一个USHORT的��|��不可误会�Q�。发��Cؓk�Q�这时修改pBlock的nFirst为k。然后，�q�回pFree。此时MemoryPool的结构如�?6-4所�C��?/p>
�?-4 MemoryPool的结�?/strong>

可以看到�Q�原来的�W?个可供分配的单元�Q�m�~�号处）已经昄��分配的状态。而pBlock的nFirst已经指向原来m单元下一个自由分配单元的�~�号�Q�即k�?/p>
�Q?�Q�MemoryPool回收内存�Ӟ��

void MemoryPool::Free( void* pFree ) { …… MemoryBlock* pMyBlock = pBlock; while ( ((ULONG)pMyBlock->aData > (ULONG)pFree) || ((ULONG)pFree >= ((ULONG)pMyBlock->aData + pMyBlock->nSize)) )�? { …… } pMyBlock->nFree++; �? *((USHORT*)pFree) = pMyBlock->nFirst; �? pMyBlock->nFirst = (USHORT)(((ULONG)pFree-(ULONG)(pBlock->aData)) / nUnitSize);�? if (pMyBlock->nFree*nUnitSize == pMyBlock->nSize )�? { …… } else { …… } }

如前所�q�ͼ�回收分配单元�Ӟ��可能会将整个内存块返回给�q�程堆，也可能将被回收分配单元所属的内存块移臛_��存池的内存块链表的头部。这两个操作都需要修攚w��表结构。这旉��要知道该内存块在链表中前一个位�|�的内存块�?/p>
①处遍历内存池的内存块链表，��定该待回收分配单元�Q�pFree�Q�落在哪一个内存块的指针范围内�Q�通过比较指针值来��定�?/p>
�q�行到②处，pMyBlock��x��到的包含pFree所指向的待回收分配单元的内存块�Q�当�Ӟ��q�时应该�q�需要检�?pMyBlock为NULL时的情�Ş�Q�即pFree不属于此内存池的范围�Q�因此不能返回给此内存池�Q�读者可以自行加上）。这时将pMyBlock�?nFree递增1�Q�表�C�此内存块的自由分配单元多了一个�?/p>
③处用来修改该内存块的自由分配单元链表的信息�Q�它��这个待回收分配单元的头两个字节的值指向该内存块原来的�W�一个可分配的自由分配单元的�~�号�?/p>
④处��pMyBlock的nFirst值改变�ؓ指向�q�个待回收分配单元的�~�号�Q�其�~�号通过计算此单元的起始位置相对pMyBlock的aData位置的差��|��然后除以步长�Q�nUnitSize�Q�得到�?/p>
实质上，③和④两步的作用��是��此待回收分配单�?真正回收"。值得注意的是�Q�这两步实际上是使得此回收单元成为此内存块的下一个可分配的自由分配单元，卛_��它放在了自由分配单元链表的头部。注意，其内存地址�q�没有发生改变。实际上�Q�一个分配单元的内存地址无论是在分配后，�q�是处于自由状态时�Q�一直都不会变化。变化的只是其状态（已分�?自由�Q�，以及当其处于自由状态时在自由分配单元链表中的位�|��?/p>
⑤处��查当回收完毕后，包含此回收单元的内存块的所有单元是否都处于自由状态，且此内存是否处于内存块链表的头部。如果是�Q�将此内存块整个的返回给�q�程堆，同时修改内存块链表结构�?/p>
注意�Q�这里在判断一个内存块的所有单元是否都处于自由状态时�Q��ƈ没有遍历其所有单元，而是判断nFree乘以 nUnitSize是否�{�于nSize。nSize是内存块中所有分配单元的大小�Q�而不包括头部MemoryBlock�l�构体的大小。这里可以看到其用意�Q�即用来快速检查某个内存块中所有分配单元是否全部处于自��q��态。因为只需�l�合nFree和nUnitSize来计��得出结论，而无��遍历和计算所有自��q��态的分配单元的个数�?/p>
另外�q�需注意的是�Q�这里�ƈ不能比较nFree与nInitSize或nGrowSize的大��来判断某个内存块中所有分配单元都��q��态，�q�是因�ؓ�W?�ơ分配的内存块（分配单元个数为nInitSize�Q�可能被�U�d��链表的后面，甚至可能在移到链表后面后�Q�因为某个时间其所有单元都处于自由状态而被整个�q�回�l�进�E�堆。即在回收分配单元时�Q�无法判定某个内存块中的分配单元个数到底是nInitSize�q�是nGrowSize�Q�也��无法通过比较nFree与nInitSize或nGrowSize的大��来判断一个内存块的所有分配单元是否都��q��态�?/p>
以上面分配后的内存池状态作��Z��子，假设�q�时�W?个内存块中的最后一个单元需要回�Ӟ��已被分配�Q�假讑օ��~�号为m�Q�pFree指针指向它）�Q�如�?-5所�C��?/p>
不难发现�Q�这时nFirst的值由原来�?变�ؓm。即此内存块下一个被分配的单元是m�~�号的单元，而不�?�~�号的单元（最先分配的是最新回收的单元�Q�从�q�一点看�Q�这个过�E�与栈的原理�c�M��Q�即先进后出。只不过�q�里�?�q?意味着"回收"�Q��?�?则意味着"分配"�Q�。相应地�Q�m�?下一个自由单�?标记�?�Q�即内存块原来的"下一个将被分配出�ȝ��单元"�Q�这也表明最�q�回收的分配单元被插��C��内存块的"自由分配单元链表"的头部。当�Ӟ��nFree递增1�?/p>
�?-5 分配后的内存池状�?/strong>

处理至⑥处之前，其状态如�?-6所�C��?/p>
�?-6 处理至⑥处之前的内存池状�?/strong>

�q�里需要注意的是，虽然pFree�?回收"�Q�但是pFree仍然指向m�~�号的单元，�q�个单元在回收过�E�中�Q�其头两个字节被覆写�Q�但其他部分的内容�ƈ没有改变。而且从整个进�E�的内存使用角度来看�Q�这个m�~�号的单元的状态仍然是"有效�?。因��里的"回收"只是回收�l�了内存池，而�ƈ没有回收�l�进�E�堆�Q�因此程序仍然可以通过pFree讉K��此单元。但是这是一个很危险的操作，因�ؓ首先该单元在回收�q�程中头两个字节已被覆写�Q��ƈ且该单元可能很快��׃��被内存池重新分配。因此回收后通过pFree指针对这个单元的讉K��都是错误的，��L��作会��d��错误的数据，写操作则可能会破坏程序中其他地方的数据，因此需要格外小心�?/p>
接着�Q�需要判断该内存块的内部使用情况�Q�及其在内存块链表中的位�|�。如果该内存块中省略�?……"所表示的其他部分中�q�有被分配的单元�Q�即nFree乘以nUnitSize不等于nSize。因为此内存块不在链表头�Q�因此还需要将其移到链表头部，如图6-7所�C��?/p>
�?-7 因回收引��L��MemoryBlock�U�d��

如果该内存块中省略号"……"表示的其他部分中全部都是自由分配单元�Q�即nFree乘以nUnitSize�{�于nSize。因为此内存块不在链表头�Q�所以此旉��要将此内存块整个回收�l�进�E�堆�Q�回收后内存池的�l�构如图6-8所�C��?/p>
�?-8 回收后内存池的结�?/strong>

一个内存块在申请后会初始化�Q�主要是��Z��建立最初的自由分配单元链表�Q�下面是其详�l�代码：

MemoryBlock::MemoryBlock (USHORT nTypes, USHORT nUnitSize) : nSize (nTypes * nUnitSize), nFree (nTypes - 1), �? nFirst (1), �? pNext (0) { char * pData = aData; �? for (USHORT i = 1; i < nTypes; i++) �? { *reinterpret_cast(pData) = i; �? pData += nUnitSize; } }

�q�里可以看到�Q�①处pData的初值是aData�Q�即0�~�号单元。但是②处的循环中i却是�?开始，然后在��@环内部的③处��pData的头两个字节值置为i。即0号单元的头两个字节��gؓ1�Q?号单元的头两个字节��gؓ2�Q�一直到�Q�nTypes-2�Q�号单元的头两个字节��gؓ�Q�nTypes-1�Q�。这意味着内存块初始时�Q�其自由分配单元链表是从0号开始。依�ơ串联，一直到倒数�W?个单元指向最后一个单元�?/p>
�q�需要注意的是，在其初始化列表中�Q�nFree初始化�ؓnTypes-1�Q�而不是nTypes�Q�，nFirst初始化�ؓ 1�Q�而不�?�Q�。这是因为第1个单元，�?�~�号单元构造完毕后�Q�立��M��被分配。另外注意到最后一个单元初始�ƈ没有讄��头两个字节的��|��因�ؓ该单元初始在本内存块中�ƈ没有下一个自由分配单元。但是从上面例子中可以看刎ͼ�当最后一个单元被分配�q�回收后�Q�其头两个字节会被设�|��?/p>
�?-9所�C�Zؓ一个内存块初始化后的状态�?/p>
�?-9 一个内存块初始化后的状�?/strong>

当内存池析构�Ӟ��需要将内存池的所有内存块�q�回�l�进�E�堆�Q?/p>

MemoryPool::~MemoryPool() { MemoryBlock* pMyBlock = pBlock; while ( pMyBlock ) { …… } }

6.2.4 使用�Ҏ��

分析内存池的内部原理后，本节说明如何使用它。从上面的分析可以看刎ͼ�该内存池主要有两个对外接口函敎ͼ�即Alloc�?Free。Alloc�q�回所甌��的分配单元（固定大小内存�Q�，Free则回收传入的指针代表的分配单元的内存�l�内存池。分配的信息则通过 MemoryPool的构造函数指定，包括分配单元大小、内存池�W?�ơ申��L��内存块中所含分配单元的个数�Q�以及内存池后箋甌��的内存块所含分配单元的个数�{��?/p>
�l�g��所�q�ͼ�当需要提高某些关键类对象的申��P��回收效率�Ӟ��可以考虑��该�c�L��有生成对象所需的空间都从某个这��L��内存池中开辟。在销毁对象时�Q�只需要返回给该内存池�?一个类的所有对象都分配在同一个内存池对象�?�q�一需求很自然的设计方法就是�ؓ�q�样的类声明一个静态内存池对象�Q�同时�ؓ了让其所有对象都从这个内存池中开辟内存，而不是缺省的从进�E�堆中获得，需要�ؓ该类重蝲一个new�q�算�W�。因为相应地�Q�回收也是面向内存池�Q�而不是进�E�的�~�省堆，�q�需要重载一个delete�q�算�W�。在new�q�算�W�中用内存池的Alloc函数满��所有该�c�d��象的内存��h��Q�而销毁某对象则可以通过�?delete�q�算�W�中调用内存池的Free完成�?/p>
6.2.5 性能比较

��Z��试利用内存池后的效果，通过一个很��的��试�E�序可以发现采用内存池机制后耗时�?97 ms。而没有采用内存池机制则耗时625 ms�Q�速度提高�?2.48%。速度提高的原因可以归�l��ؓ几点�Q�其一�Q�除了偶��的内存甌��和销毁会��D��从进�E�堆中分配和销毁内存块外，�l�大多数的内存申请和销毁都由内存池在已�l�申请到的内存块中进行，而没有直接与�q�程堆打交道�Q�而直接与�q�程堆打交道是很耗时的操作；其二�Q�这是单�U�程环境的内存池�Q�可以看到内存池的Alloc和Free操作中�ƈ没有加线�E�保护措施。因此如果类A用到该内存池�Q�则所有类A对象的创建和销毁都必须发生在同一个线�E�中。但如果�c�A 用到内存池，�c�B也用到内存池�Q�那么类A的��用线�E�可以不必与�c�B的��用线�E�是同一个线�E��?/p>
另外�Q�在�W?章中已经讨论�q�，因�ؓ内存池技术��得同�c�d��的对象分布在盔R��的内存区域，而程序会�l�常对同一�c�d��的对象进行遍历操作。因此在�E�序�q�行�q�程中发生的�~�页应该会相应少一些，但这个一般只能在真实的复杂应用环境中�q�行验证�?/p>

回页�?/font>

6.3 本章��结

内存的申请和释放对一个应用程序的整体性能影响极大�Q�甚臛_��很多时候成为某个应用程序的瓉��。消除内存申请和释放引�v的瓶颈的�Ҏ��往往是针对内存��用的实际情况提供一个合适的内存池。内存池之所以能够提高性能�Q�主要是因�ؓ它能够利用应用程序的实际内存使用场景中的某些"�Ҏ�?。比如某些内存申请与释放肯定发生在一个线�E�中�Q�某�U�类型的对象生成和销毁与应用�E�序中的其他�c�d��对象要频�J�得多，�{�等。针对这些特性，可以��些特�D�的内存使用场景提供量��n定做的内存池。这栯��够消除系�l�提供的�~�省内存机制中，对于该实际应用场景中的不必要的操作，从而提升应用程序的整体性能�?/p>

��果�?/a> 2011-04-05 20:18 发表评论

c++ 内存泄露(�?

Tue, 05 Apr 2011 12:11:00 GMT

内存泄露�怿�对C++�E�序员来说都不陌生。解军_��存泄露的�Ҏ��多种多样�Q�大部分�Ҏ��以追�t�检��ؓ主，�q�种�Ҏ��实现��h��Ҏ��Q��用方便，也比较安全�?/p>
    首先我们要确定这个模块的主要功能�Q?/p>

能追�t�内存的分配和释放过�E��?/li>
要能昄��内存分配的相关信息，比如内存块大��，代码所在文件所在行�{��?/li>
在发现内存泄露时及时�l�出相关信息�?/li>
能正��处理一些异常情况，比如内存不��Q�对象初始化��p�|�{�等�?/li>
是线�E�安全的。[*�q�个�q�没有实现]

   有了一些基本功能需求，我们需要考虑每种功能怎么��d��现。首先，我们可以通过重蝲的方式来�q�踪new,delete.malloc和free�Q�C++�l�我提供了这��L��Ҏ��。因为本文主要针对C++�Q�所以主要讲重蝲new,delete的方法，malloc和free的重载实��C��此类��|��最�l�版本的�E�序中也实现了malloc和free的重载�?a id=more>

1.重蝲new和delete

   首先我们要了解一下new和delete是怎么工作的。C++中的操作�W�最�l�都会被转换成函数�Ş式，例如"new int"会变�?opetaor new(sizeof(int))"�Q��?new double[10]"会变�?operator new(sizeof(double)*10)"�Q�同�?#8220;delete p”��变成了"operator delete(p)"。另外一个需要特别注意的地方是，new对于用户定义的数据类型（即你的自定义�c�）会自动调用该�c�d��的构造函敎ͼ�如果构造函数没有抛出异常，则正��分配，否则会中断分配操作，��异�怼�递给用户。默认情况下�Q�new可以对象构造异常进行捕莗��另外一个版本的new��是不带捕获异常功能的的了，所以C++�pȝ��提供的new和delete有：

?

1

2

3

4

5

6

7

8

9

void* operator new(size_t size)throw(std::bad_alloc);

void* operator new[](size_t size) throw(std::bad_alloc);

void* operator new(size_t,std::nothrow_t&)throw();

void* operator new[](size_t,std::nothrow_t&)throw();

void operator delete(void* pointer);

void operator delete[](void* pointer);

void operator delete(void* pointer,std::nothrow_t&);

void operator delete[](void* pointer,std::nothrow_t&);

   其中�Q�nothrow_t是一个空�l�构�?#8220;struct nothrow_t{}"�Q�它的一个实例就是nothrow�Q�C++用它来区分可以捕获异常的new和不可捕获异常的new。我们不能直接修改内部函数的行�ؓ�Q�但是我们可以重载它们。�ؓ了实现提供内存分配信息的功能�Q�我们给重蝲的函数加上几个参数。得��C��下函敎ͼ�

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

void* operator new(size_t size);

void* operator new[](size_t size);

void* operator new(size_t,std::nothrow_t&)throw();

void* operator new[](size_t,std::nothrow_t&)throw();

void* operator new(size_t size,const char* file,const char* func,const int line)throw(std::bad_alloc);

void* operator new[](size_t size,const char* file,const char* func,const int line) throw(std::bad_alloc);

void* operator delete(void* pointer);

void* operator delete[](void* pointer);

/*******Placement Delete********/

void operator delete(void* pointer,const char* file,const char* func,const int line);

void operator delete[](void* pointer,const char* file,const char* func,const int line);

void operator delete(void* pointer,std::nothrow_t&);

void operator delete[](void* pointer,std::nothrow_t&);

/*******************************/

    中间的几个函敎ͼ��是我们主要需要重载的函数�Q�模块的大部分工作也都由着几个函数完成。这些函数参��C��Q�file表示分配代码所在的文�g名，func表示代码所在的函数名，line表示代码行号。这几个参数信息我们可以通过�~�译器预定义好的几个宏来获得�Q�__FILE__,__FUNCTION__,__LINE__。也��是说可以将"new ..."替换�?new(__FILE__,__FUNCTION__,__LINE__) ..."�Q�最�l�成�?operator new(sizeof(...),__FILE__,__FUNCTION__,__LINE__)"的�Ş式，也就辑ֈ�了我们的目的。关�?placement delete��在下面详细解释�?/p>
2.�I�间分配

   接下来我们要考虑内存分配信息的组�l�问题了。我们先来了解一下编译器是怎么�l�织的。在大部分编译器中，new所分配的空间都要大于实际申��L��I�间�Q�大出来的部分就是编译器定义的内存块的信息，包括了内存块的大��还有一些其他信息。如下图所�C�：

   我们把包含内存分配信息的部分叫做cookie数据。�ؓ了方便，我们把cookie数据攑֜�分配的内存的起始位置�Q�之后紧接有效数据区。我们还需要把�q�回�l�调用者的指针和new分配的数据区联系��h��Q�原本想用性能比较好的STL的map数据�l�构来储存这些数据，但是map内部同样也��用new来分配内存，所以如果直接��用map来储存，��׃��陷入��d�@环中。所以这里我们必��自��q��实一个数据结构。我们可以对�q�回�l�调用者的地址�q�行Hash�Q�得到hash 表中的地址�Q�具有相同Hash值的数据我们用一个单向链表连接�v来。最�l�的数据�l�构如下图所�C�：

2.1.构造函��C��的异�?/strong>

   另外一个必��要注意的一�Ҏ��Q�new操作�W�会先分配空间然后调用用戯��定义�c�d��的构造函敎ͼ�如果构造函数抛出异常，需要用��h��动释攑ַ�分配的内存。问题在于释放这��L��内存不能用一般的delete操作�W�，可以用一个例子来说明�Q?/p>

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

#include

#include

void* operator new(size_t size, int line) {

    printf("Allocate %u bytes on line %d\\n", size, line);

    return operator new(size);

}

class UserClass {

public:

    UserClass(int n)throw(){

        if(n<=0){

             throw std::runtime_error("n must be positive");

        }

    }

};

int main(){

    try{

        UserClass* myobj=new(__LINE__) UserClass(-10);

        delete myobj; //doesn't work if placement was not defined

    } catch(const std::runtime_error& e) {

        fprintf(stderr,"Exception: %s\n",e.what());

    }

    return 0;

}

   �q�里�Q�虽然在new�q�后试图使用delete释放已经分配的内存，但是实际上不会释放。也�怽�的编译器会给��样一条消息：

        “no matching operator delete found”

        ��Z��正确处理�q�种情况�Q��ƈ�l�用��h��供相关的信息�Q�我们需要定义placement delete操作�W�。placement delete是C++98标准中才有的一个特性，所以对于某些老的�~�译器（大致可以认�ؓ是指那些98�q�以前编写的�~�译器）不支持这个特性。这需要在模块中添加宏定义让用户可以关闭placement delete的定义，以便模块能在较老的�~�译器上�~�译。以下就是需要定义的placement delete操作�W�：

?

1

2

3

4

void operator delete(void* pointer,const char* file,const char* func,const int line);

void operator delete[](void* pointer,const char* file,const char* func,const int line);

void operator delete(void* pointer,std::nothrow_t&);

void operator delete[](void* pointer,std::nothrow_t&);

3.��查内存泄�?/strong>

   有了上面的实玎ͼ�我们可以方便的手动检��内存泄霌Ӏ�通过一个函数来实现�Q�它会检索整个hash表，如果表不为空则存在内存泄霌Ӏ?/p>
   ��Z��辑ֈ�在最后程序退出时��查内存泄露的目的�Q�我们需要在所有对象调用析构函数后�q�行内存泄露��，�q�是因�ؓ某些用户�c�d��在构造函数里调用new而在析构函数里调用delete。这样做能大大的减小误报的概率。而且因�ؓ对象的析构函数的调用往往在主函数main()执行�l�束之后�q�行�Q�所以我们也不能直接在主函数里进行内存泄露检��。这里我们利用一个全局对象来实现这�U�检��。首先我们定义一个类�Q?/p>

?

1

2

3

4

5

6

7

8

9

10

11

class MemCheck{

    public:

        MemCheck(){

            memset(pTable,0,sizeof(mc_block_node_t*) * MC_HASHTABLESIZE);

        }

        ~MemCheck(){

            if(mc_checkmem()){

                abort();

            }

        }

};

   �q�里的构造函数初始化Hash表。析构函数检��内存泄霌Ӏ�然后定义一个MemCheck的全局静态对象，�q�样当程序运行之前会初始化hash表，�E�序退出时��内存泄霌Ӏ�可是问题又来了�Q�如果一个程序中有多个全局静态对象会怎样�Q�不�q�的是，对于全局静态对象的构造顺序和析构��序是C++标准中的一个未定义问题�Q�也��是��_��q�个��序取决于编译器的具体实现。考虑�Q�绝大多数��^��C��用VC和GCC�~�译器，我们可以针对�q�两�U�编译器来控制全局对象的构造和解析��序�?/p>

?

1

2

3

4

5

6

7

8

9

#ifdef _MSC_VER

#pragma init_seg(lib)

#endif

static MemCheck mc_autocheck_object

#ifdef __GNUC__

__attribute__((init_priority (101)))

#endif

;

   �q�里的宏定义部分都是�~�译器的选项�?/p>

��果�?/a> 2011-04-05 20:11 发表评论

PE学习�ȝ��

Tue, 12 Oct 2010 09:22:00 GMT
     摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->#include "windows.h"#include using namespace std;#define NTSI...  阅读全文

��果�?/a> 2010-10-12 17:22 发表评论

__type_traits(�?

Mon, 11 Oct 2010 01:24:00 GMT

在STL中�ؓ了提供通用的操作而又不损失效率，我们用到了一�U�特�D�的技巧，叫traits�~�程技巧。具体的来说�Q�traits��是通过定义一些结构体或类�Q��ƈ利用模板�cȝ��化和偏特化的能力�Q�给�c�d��赋予一些特性，�q�些�Ҏ��根据类型的不同而异。在�E�序设计中可以��用这些traits来判断一个类型的一些特性，引发C++的函数重载机�Ӟ��实现同一�U�操作因�c�d��不同而异的效果。traits的编�E�技巧极度��I补了C++语言的不��?�?/strong>

举例�Q?br>
现在定义一个__type_traits可以获得�c�d��的如下属性：
1. 是否存在non-trivial default constructor
2. 是否存在non-trivial copy constructor
3. 是否存在non-trivial assignment operator
4. 是否存在non-trivial destructor

struct __true_type {
};
struct __false_type {
};

template
struct __type_traits {

   typedef __false_type    has_trivial_default_constructor;
   typedef __false_type    has_trivial_copy_constructor;
   typedef __false_type    has_trivial_assignment_operator;
   typedef __false_type    has_trivial_destructor;
};

问题�Q��ؓ什么把对象的所有的属性都定义为__false_type�Q?br> �q�样是采用最保守的做法，先把所有的对象属性都讄��为__false_type�Q�然后在针对每个基本数据�c�d��设计特化的__type_traits�Q�就可以辑ֈ�预期的目的，如可以定义__type_traits如下�Q?br>
template <>
struct __type_traits {
   typedef __true_type    has_trivial_default_constructor;
   typedef __true_type    has_trivial_copy_constructor;
   typedef __true_type    has_trivial_assignment_operator;
   typedef __true_type    has_trivial_destructor;
};

template <>
struct __type_traits {
   typedef __true_type    has_trivial_default_constructor;
   typedef __true_type    has_trivial_copy_constructor;
   typedef __true_type    has_trivial_assignment_operator;
   typedef __true_type    has_trivial_destructor;
};

    ......

    ......

其他基本�c�d��的traits也可以有相应的定�?br>
__type_traits的偏特化版本
template
struct __type_traits<_Tp*> {
   typedef __true_type    has_trivial_default_constructor;
   typedef __true_type    has_trivial_copy_constructor;
   typedef __true_type    has_trivial_assignment_operator;
   typedef __true_type    has_trivial_destructor;
   typedef __true_type    is_POD_type;
};

我们可以自定义__type_traits的特化版�?br> 比如对与自定义的Shape�c�d��Q�我们可以这样定义__type_traits
struct __type_traits {
   typedef __false_type    has_trivial_default_constructor;
   typedef __true_type    has_trivial_copy_constructor;
   typedef __true_type    has_trivial_assignment_operator;
   typedef __true_type    has_trivial_destructor;
   typedef __true_type    is_POD_type;
};

如果�~�译器够厉害�Q�我们甚臛_��以不用自己去定义特化的__type_traits�Q�编译器��p��够帮我们搞定�Q�）

如何使用呢？

假设现在用个模板函数fun需要根据类型T是否有non-trivial constructor来进行不同的操作�Q�可以这��h��实现�Q?br>
template
void fun()
{
     typedef typename __type_traits::has_trivial_constructor _Trivial_constructor;
    __fun(_Trivial_constructor()); // �Ҏ��得到的_Trivial_constructor来调用相应的函数
}

// 两个重蝲的函�?br> void _fun(_true_type)
{
cout<<"fun(_true_type)called"< }
void _fun(_false_type)
{
cout<<"fun(_false_type) called"< }

//��试代码

int main()
{
fun();
fun();
fun();
fun();
}

��果�?/a> 2010-10-11 09:24 发表评论

Traits学习--�q�代�?1)

Sat, 09 Oct 2010 05:23:00 GMT

用template要求写一个模板函敎ͼ��q�回��D��求是参数�c�d��Q�初步设�?br>template<typename T>
class AIter{
public:
    AIter(T* p=0):ptr(p){};
    T* ptr;
    typedef T value_type;
    T& operator*()const{
        return *ptr;
    }
    T* operator->()const{
        return ptr;
    }
};
template<typename T>
typename T::value_type
func(T val){
    return *val;
}

�q�方法一个缺陷就是对于不是class type的类型无能�ؓ�?比如原生指针,只有class type�c�d��才能内嵌�c�d��

改进--模板偏特�?template partial specialization)
声明一个类�?br>template
struct stl_iterator_traits{
    typedef typename T::value_type value_type;
};
原先的func可以写成�q�样
template
typename stl_iterator_traits::value_type
func(T val){
    return *val;
}
�q�样�q�是处理不了
int* p=new int(3);
func(p);
原生指针�c�d��Q��ؓ其提供特化版�?br>template
struct stl_iterator_traits{
    typedef T value_type;
};
�q�样��p��完美解决刚才问题

但是对于指向常数对象的指�?br>stl_iterator_traits::value_type
我们希望暂时存储一个变量，但是我们获取的类型是const int,声明一个无法赋值的临时变量无意义，所以我们在提供一个特化版�?br>template
struct stl_iterator_traits{
    typedef T value_type;
};
iterator example:

#include <iterator>
//#using
#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>
//using namespace System;
using namespace std;

template<typename T>
class ListItem{
public:
    ListItem(T value){
        _value=value;
        _next=NULL;
    }
    ListItem(){
        _next=NULL;
        _value=0;
    }
    T value()const{
        return _value;
    }
    ListItem<T>* _next;
    T _value;
};
template<class Item>
class ListIter:public iterator<std::forward_iterator_tag,Item>{
public:
    Item* ptr;
    ListIter(Item* p=0):ptr(p){};
    Item& operator*()const{
        return *ptr;
    }
    Item* operator->()const{
        return ptr;
    }
    ListIter& operator++(){
        ptr=ptr->_next;
        return *this;
    }
    ListIter operator++(int){
        ListIter tmp=*this;
        ++(*this);
        return tmp;
    }
    bool operator==(const ListIter& iter)const{
        return ptr==iter.ptr;
    }
    bool operator!=(const ListIter& iter)const{
        return ptr!=iter.ptr;
    }
};
template<typename T>
bool operator==(ListItem<T>& item,T value){
    return item.value()==value;
}

template<typename T>
class List{
public:
    typedef ListIter<ListItem<T> > iterator;
    List(){
        _end=new ListItem<T>();
        _front=0;
    }
    void insert_front(T value){
        ListItem<T>* item=new ListItem<T>(value);
        if(empty()){
            item->_next=_end;
            _front=item;
        }else{
            item->_next=_front;
            _front=item;
        }
    };
    bool empty(){
        return _front==NULL;
    }
    void insert_end(T value){
        //ListItem* item=new ListItem(value);
        if(empty()){
            _front=_end;
            _end->_value=value;
            _end->_next=new ListItem<T>();
            _end=_end->_next;
        }else{
            _end->_value=value;
            _end->_next=new ListItem<T>();
            _end=_end->_next;
        }
    };
    void display(ostream& os=cout){
        ListItem<T>* head=_front;
        while(head!=_end){
            cout<<head->value()<<endl;
            head=head->_next;
        }
    };
    ListItem<T>* front(){
        return _front;
    }
private:
    ListItem<T>* _end;
    ListItem<T>* _front;
    long _size;
};

template<typename T>
struct stl_iterator_traits{
    typedef typename T::value_type value_type;
};

template<typename T>
struct stl_iterator_traits<T*>{
    typedef T value_type;
};

template<typename T>
class AIter{
public:
    AIter(T* p=0):ptr(p){};
    T* ptr;
    typedef T value_type;
    T& operator*()const{
        return *ptr;
    }
    T* operator->()const{
        return ptr;
    }
};
template<typename T>
typename stl_iterator_traits<T>::value_type
func(T val){
    return *val;
}
int _tmain(int argc, _TCHAR* argv[])
{
    List<int> list;
    for(int i=0;i<5;i++){
        list.insert_front(i);
        list.insert_end(i+2);
    }
    list.display();


    List<int>::iterator begin(list.front());
    List<int>::iterator end;
    List<int>::iterator iter;

    //vector::iterator itere;
    AIter<int> it(new int(2));

    iter=find(begin,end,2);
    cout<<iter->value()<<endl;
    //list.insert_end(1);
    //list.insert_end(2);
    //list.display();
    //list.insert_end(
    return 0;
}

现在对于class type �q�代器AIter,�q�是原生指针int* 或const int*,都能获取正确�c�d��int
stl规定�Q�每个�P代器都要自己内嵌型别定义的方式定义出相应型别
(待箋...)

��果�?/a> 2010-10-09 13:23 发表评论

Effective C++�q�蝲(�?

Fri, 08 Oct 2010 01:19:00 GMT
     摘要: �W�一�?从C转向C++ �Ҏ��个�h来说�Q�习惯C++需要一些时��_��对于已经熟悉C的程序员来说�Q�这个过�E�尤其��o��恹{��因为C是C++的子集，所有的C的技术都可以�l�箋使用�Q�但很多用�v来又不太合适。例如，C++�E�序员会认�ؓ指针的指针看��h��很古怪，他们会问�Q��ؓ什么不用指针的引用来代替呢�Q�C 是一�U�简单的语言。它真正提供的只有有宏、指针、结构、数�l�和函数。不��什么问题，C都靠宏、指针、结构、数�l�和函数来解�?..  阅读全文

��果�?/a> 2010-10-08 09:19 发表评论