Winx基本类参考手册之AutoFreeAllocT

Winx基本类参考手册之AutoFreeAllocT

AutoFreeAllocT类

 

template <class _Alloc, int _MemBlockSize = MEMORY_BLOCK_SIZE>

class AutoFreeAllocT

 

参数

_Alloc

实际分配内存空间的类。

 

_MemBlockSize

分配内存时，每个内存块的大小（以字节为单位）。缺省大小为MEMORY_BLOCK_SIZE ，即2048个字节。

 

枚举常量

MemBlockSize

内存块的大小，与_MemBlockSize相同。

 

HeaderSize

内存块头部信息的大小。

 

BlockSize

实际可用内存块的大小（MemBlockSize - HeaderSize）。

 

IsAutoFreeAlloctor

指定是否是自动释放的内存分配器。

 

成员函数

AutoFreeAllocT()

缺省构造函数，初始化为内存未分配。

 

AutoFreeAllocT(_Alloc alloc)

构造函数，初始化为内存未分配。

参数

                            _Alloc alloc       指定实际分配内存空间的类。

 

~AutoFreeAllocT()

析构函数，释放分配的内存块。该函数调用clear()。

 

void* allocate(size_t cb)

分配内存。

参数

                            size_t cb                         需要分配内存的大小。

 

void* allocate(size_t cb, DestructorType fn)

分配内存。

参数

                            size_t cb                        

需要分配内存的大小。

DestructorType fn         

                        指定分配内存的析构方式。

 

void* allocate(size_t cb, int fnZero)

与void* allocate(size_t cb)相同，用于原生类型（int、long、char等）的特化。

 

void winx_call clear()

释放分配的内存块。

 

void winx_call swap(AutoFreeAllocT& o)

交换AutoFreeAllocT的实例。

参数

                            AutoFreeAllocT& o

                                          所要交换AutoFreeAllocT的实例。

 

例子

 

class ClassA

{

private:

      int            var_int_;

      double           var_double_;

public:

      ClassA() { }

};

 

class ClassB

{

private:

      int            var_int_;

      double           var_double_;

public:

      ClassB() : var_int_(0), var_double_(0.0)  { }

      ClassB(const ClassB& cb) :

            var_int_(cb.var_int_), var_double_(cb.var_double_)

      {}

     

      ~ClassB() { }

};

 

 

class ClassC

{

private:

      int            var_int_;

      double           var_double_;

      ClassB           class_b_;

public:

 

      ClassC() { }

      ~ClassC() { }

};

 

int main()

{

      AutoFreeAlloc alloc;

 

      ClassA* ca = STD_NEW(alloc, ClassA);

      ClassA* caArray = STD_NEW_ARRAY(alloc, ClassA, 100);

        for (int i = 0; i < 100; ++i)

        {

                // print address of each element of Array caArray

                cout << caArray + i << endl;

      }

 

      ClassB cbTemp;

      // assign cbTemp to cb

      ClassB* cb = STD_NEW(alloc, ClassB)(cbTemp);

      ClassB* cbArray = STD_NEW_ARRAY(alloc, ClassB, 100);

 

      ClassC* cc = STD_NEW(alloc, ClassC);

      ClassC* ccArray = STD_NEW_ARRAY(alloc, ClassC, 100);

 

      // assign 1 to i1

      int* i1 = STD_NEW(alloc, int)(1);

      int* i2 = STD_NEW_ARRAY(alloc, int, 100);

 

      // assign 0.0 to d1

      double* d1 = STD_NEW(alloc, double)(0.0);

      double* d2 = STD_NEW_ARRAY(alloc, double, 100);

 

        int* i3 = STD_ALLOC(alloc, int);

        int* i4 = STD_ALLOC_ARRAY(alloc, int, 100);

 

        double* d3 = STD_ALLOC(alloc, double);

      double* d4 = STD_ALLOC_ARRAY(alloc, double, 100);

     

        char* s1 = STD_NEW(alloc, char);

        *s1 = 'T';

        cout << *s1 << endl;

        char* s2 = STD_NEW_ARRAY(alloc, char, 128);

        strcpy(s2, "hello world!");

        cout << s2 << endl;

 

        char* s3 = STD_NEW(alloc, char);

        char* s4 = STD_NEW_ARRAY(alloc, char, 128);

        strcpy(s4, "hello world 2!");

      cout << s4 << endl;

      return 0;

}