如何在程序中使用OGRE提供的内存策略

要使用OGRE提供的内存策略（或自定义的内存策略）主要有两种方式：

1. 继承AllocatedObject类

2. 使用OgreMemoryAllocatorConfig.h头文件中定义的内存操作宏

继承AllocatedObject类

AllocatedObject类中重载了new、new[]、delete及delete[]等操作符，所以若要A类使用Ogre提供的或自定义的内存策略，只需继承AllocatedObject类即可。AllocatedObject类以模板的形式支持各种内存分配策略。在OgreMemoryAllocatorConfig.h头文件中对各种模板的AllocatedObject类进行了“重命名”，例如：

typedef CategorisedAllocPolicy<Ogre::MEMCATEGORY_GENERAL> GeneralAllocPolicy;

typedef AllocatedObject<GeneralAllocPolicy> GeneralAllocatedObject;

typedef GeneralAllocatedObject  ArchiveAlloc;

typedef GeneralAllocatedObject  ConfigAlloc;

所以在继承使用AllocatedObject类时，可考虑使用OgreMemoryAllocatorConfig.h头文件中的宏定义。例如：

（举例多取自OGRE源码，一般都标注了其文件名）

class _OgreExport ConfigFile : public ConfigAlloc //OgreConfigFile.h

class _OgreExport ArchiveManager : public Singleton<ArchiveManager>, public ArchiveAlloc  // OgreArchiveManager.h

而为了统一形式，在OgreMemoryAllocatorConfig.h头文件中为继承自AllocatedObject的类定义如下两个宏：

#define OGRE_NEW new

#define OGRE_DELETE delete

因此在使用时，形式如下

ArchiveManager* mArchiveManager = OGRE_NEW ArchiveManager();

使用内存操作宏

除了继承使用AllocatedObject类之外，对于C++中的原始类型(int, double等)，或者来自外部库的不能更改的类型，或者某些原因而不能继承AllocatedObject的类型来说，如果要对它们使用Ogre自定义内存策略，则可以使用OgreMemoryAllocatorConfig.h头文件中定义的内存操作宏:

以下三个宏用于分配原始内存，只是分配相应大小的内存，并不进行初始化:

OGRE_MALLOC(bytes, category)

-- 分配bytes大小的内存

OGRE_ALLOC_T(T, count, category)

-- 分配sizeof(T) * count大小的内存

OGRE_FREE(ptr, category)

-- 与上述两个配对使用，释放ptr指向的内存

以下四个宏分配相应内存并进行初始化:

OGRE_NEW_T(T, category)

-- 分配sizeof(T)大小的内存，并调用T的构造函数

OGRE_NEW_ARRAY_T(T, count, category)

-- 分配sizeof(T) * count大小的内存,并对count个T类型实例依次初始化

OGRE_DELETE_T(ptr, T, category)

– 与OGRE_NEW_T 配对使用，调用T的析构函数，释放相应内存

OGRE_DELETE_ARRAY_T(ptr, T, count, category)

--与OGRE_NEW_ARRAY_T配对使用，对count个T类型实例依次调用其析构函数，释放相应内存

举例：

// OgreTexture.cpp

void* pixData = OGRE_MALLOC(dataSize, Ogre::MEMCATEGORY_GENERAL);

// OgreAxisAlignedBox.h

Vector3* mpCorners = OGRE_ALLOC_T(Vector3, 8, MEMCATEGORY_SCENE_CONTROL);

OGRE_FREE(mpCorners, MEMCATEGORY_SCENE_CONTROL);

// OgreAnimationState.cpp

BoneBlendMask* mBlendMask = OGRE_NEW_T(BoneBlendMask, MEMCATEGORY_ANIMATION)(blendMaskSizeHint);

OGRE_DELETE_T(mBlendMask, BoneBlendMask, MEMCATEGORY_ANIMATION);

// OgreBspLevel.cpp

Brush * mBrushes = OGRE_NEW_ARRAY_T(BspNode::Brush, mNumBrushes, MEMCATEGORY_GEOMETRY);

OGRE_DELETE_ARRAY_T(mBrushes, Brush, (size_t)mNumBrushes, MEMCATEGORY_GEOMETRY);

对于以上7个内存操作宏分别有与其对应的对齐方式的宏定义，如OGRE_MALLOC_SIMD、OGRE_MALLOC_ALIGN、OGRE_ALLOC_T_SIMD、OGRE_NEW_T_ALIGN、OGRE_DELETE_ARRAY_T_ALIGN 等等。

***使用这些宏时，如果类型T本身继承于AllocatedObject，对程序本身也不会产生什么坏的影响，除了显得多此一举。

Ogre提供的内存分配/释放跟踪器

在Ogre自己提供的NedAllocPolicy（NedAlignedAllocPolicy）、NedPoolingPolicy（NedPoolingAlignedPolicy）、StdAllocPolicy（StdAlignedAllocPolicy）三种内存分配策略中，都包含了分配/释放跟踪功能，如需在自定义的分配策略中添加跟踪功能，照搬即可。该功能由MemoryTracker类实现，它统计内存的分配和释放情况，以及内存分配语句所在文件名、行号和函数名。默认在程序结束时将统计信息输出到终端，并保存于OgreLeaks.log文件，也可通过成员函数setReportToStdOut(bool rep)和setReportFileName(const std::string& name)设置输出方式。

跟踪器的使用方式都在分配策略中完成，无需在它处额外操作。唯一需要设置的就是跟踪器开关的打开与关闭

在OgrePrerequisites.h文件中有如下宏定义

#if OGRE_DEBUG_MODE

#if OGRE_MEMORY_TRACKER_DEBUG_MODE

#define OGRE_MEMORY_TRACKER 1

#else

#define OGRE_MEMORY_TRACKER 0

#endif

#else

#if OGRE_MEMORY_TRACKER_RELEASE_MODE

#define OGRE_MEMORY_TRACKER 1

#else

#define OGRE_MEMORY_TRACKER 0

#endif

#endif

即，OGRE_MEMORY_TRACKER宏开关取决于OGRE_MEMORY_TRACKER_DEBUG_MODE 或OGRE_MEMORY_TRACKER_RELEASE_MODE。而在OgreBuildSettings.h中定义有

#define OGRE_MEMORY_TRACKER_DEBUG_MODE 0

#define OGRE_MEMORY_TRACKER_RELEASE_MODE 0

即默认是关闭跟踪器的，如果需要在DEBUG版下打开跟踪器，只需要将OGRE_MEMORY_TRACKER_DEBUG_MODE设置为1。而根据OgreMemoryAllocatorConfig.h文件中内存操作宏的设置():

#if OGRE_DEBUG_MODE    //语句1

…//详见源文件

#else // !OGRE_DEBUG_MODE

…

#endif // OGRE_DEBUG_MODE

即便是打开了OGRE_MEMORY_TRACKER_RELEASE_MODE宏，跟踪器也不能记录内存分配语句所在文件名、行号和函数名，即不能正常工作。如果需要在Release版下正常开启跟踪器功能，建议将语句1“#if OGRE_DEBUG_MODE”改为“#if OGRE_MEMORY_TRACKER”。

举例：

对于如下代码

#include <string>

#include <OgreRoot.h>

#include <OgreMemoryAllocatorConfig.h>

#include <OgreArchiveManager.h>

using std::string;

int main()

{

{

int *pi = OGRE_NEW_T(int, Ogre::MEMCATEGORY_GENERAL)(50);

OGRE_FREE(pi, Ogre::MEMCATEGORY_GENERAL); //释放

double *pd = OGRE_NEW_ARRAY_T(double, 5, Ogre::MEMCATEGORY_GENERAL);

OGRE_FREE(pd, Ogre::MEMCATEGORY_GENERAL); //释放

string *ps =  OGRE_NEW_T(string, Ogre::MEMCATEGORY_GENERAL)("hello");

OGRE_DELETE_T(ps, string, Ogre::MEMCATEGORY_GENERAL); //释放

}

{

Ogre::ArchiveManager* mArchiveManager = OGRE_NEW Ogre::ArchiveManager();

OGRE_DELETE mArchiveManager; //释放

}

return 0;

}

现开启跟踪器宏开关，即将OGRE_MEMORY_TRACKER_DEBUG_MODE 和 OGRE_MEMORY_TRACKER_RELEASE_MODE 都置为1（须重新编译）。该代码正确释放了所有内存，不存在内存泄漏。如果将代码中释放内存的语句全部注释掉，则在Debug版下生成的OgreLeaks.log文件的内容为：

Ogre Memory: Detected memory leaks !!!

Ogre Memory: (6) Allocation(s) with total 244 bytes.

Ogre Memory: Dumping allocations ->

e:\vs project\ogretest\testmain.cpp(12) : {4 bytes} function: main

e:\vs project\ogretest\testmain.cpp(15) : {40 bytes} function: main

e:\vs project\ogretest\testmain.cpp(25) : {64 bytes} function: main

(unknown source):(0) : {52 bytes} function:

(unknown source):(0) : {52 bytes} function:

e:\vs project\ogretest\testmain.cpp(18) : {32 bytes} function: main

在Release版下生成的OgreLeaks.log文件的内容为：

Ogre Memory: Detected memory leaks !!!

Ogre Memory: (8) Allocation(s) with total 248 bytes.

Ogre Memory: Dumping allocations ->

(unknown source):(0) : {48 bytes} function:

(unknown source):(0) : {28 bytes} function:

(unknown source):(0) : {4 bytes} function:

(unknown source):(0) : {4 bytes} function:

(unknown source):(0) : {4 bytes} function:

(unknown source):(0) : {72 bytes} function:

(unknown source):(0) : {40 bytes} function:

(unknown source):(0) : {48 bytes} function:

可以看出在Debug版下，跟踪器正常工作，顺利的检测出全部四处内存泄漏，而在Release版下则不能正常工作。将“#if OGRE_DEBUG_MODE”改为“#if OGRE_MEMORY_TRACKER”后，重新在Release版下测试，跟踪器便能正常工作，生成的OgreLeaks.log的内容为：

Ogre Memory: Detected memory leaks !!!

Ogre Memory: (8) Allocation(s) with total 248 bytes.

Ogre Memory: Dumping allocations ->

(unknown source):(0) : {48 bytes} function:

.\TestMain.cpp(18) : {28 bytes} function: main

.\TestMain.cpp(12) : {4 bytes} function: main

(unknown source):(0) : {4 bytes} function:

(unknown source):(0) : {4 bytes} function:

.\TestMain.cpp(25) : {72 bytes} function: main

.\TestMain.cpp(15) : {40 bytes} function: main

(unknown source):(0) : {48 bytes} function:

P．S．

1. 测试代码中，对int和double类型使用的是OGRE_NEW_T 和 OGRE_FREE 来分别分配和释放内存，而并非前文所说的OGRE_DELETE_T，原因是因为对于int,double等基本类型来说，是没有析构函数的，而OGRE_DELETE_T宏是要调用相应析构函数的。

2. 测试代码中，若将using std::string;注释掉，并将相应string类型测试语句换为如下两句：

std::string *ps2 = OGRE_NEW_T(std::string, Ogre::MEMCATEGORY_GENERAL)("world");

OGRE_DELETE_T(ps2, basic_string, Ogre::MEMCATEGORY_GENERAL);

其中basic_string 不能是string 或 std::string ！！！  同样是因为OGRE_DELETE_T宏要调用basic_string类的析构函数。类似情况还有在使用std::fostream，std::fistream等等时。