C++内存管理-重载内存管理函数

记录学习的点点滴滴,参考侯捷<<C++内存管理>>

我们先重载一下C++的几个内存管理函数 operator new, operator new[], operator delete, operator delete[]

1.创建一个类

class Foo
{
private:
    int _id; //
    long _data;//
    string _str;//

public:
    Foo():_id()
    {
        cout << "default ctor.this=" << this << " id=" << _id << endl;
    }
    Foo(int a):_id(a)
    {
        cout << "ctor.this=" << this << " id=" << _id << endl;
    }

    //        virtual
    ~Foo()
    {
        cout << "dtor.this=" << this << " id=" << _id << endl;
    }

    //申请内存的函数必须是必须是静态的 调用这个函数时一般都是正在创建这个对象 所以当调用时你这个对象还不存在 所以需要声明成静态
    static void* operator new(size_t size);
    static void  operator delete(void* pdead, size_t size);
    static void* operator new[](size_t size);
    static void  operator delete[](void* pdead, size_t size);
};

上一节提到过operator new 和 operator delete的实现是基于malloc()和free() 这边也直接在函数内声明这两个函数

    void* Foo::operator new(size_t size)//size 为将要申请的内存大小
    {
        Foo* p = (Foo*)malloc(size);
        cout <<"operator new().sizeof()="<< size << "       return=" << p <<endl;
        return p; //p 为内存起始点
    }

    void Foo::operator delete(void* pdead, size_t size)//pdead 删除点  和上面的p为同一个位置   size 为将要删除的内存大小
    {
        cout <<"operator delete.pdead=" << pdead << "       size=" << size <<endl;
        cout << endl;
        free(pdead);
    }

    void* Foo::operator new[](size_t size)
    {
        Foo* p = (Foo*)malloc(size);
        cout <<"operator new[].size="<< size <<"     return=" << p << endl;
        return p;
    }

    void Foo::operator delete[](void* pdead, size_t size)
    {
        cout<< "operator delete[].pdead=" << pdead << "     size="<< size <<endl;
        cout << endl;
        free(pdead);
    }

下面调用一下测试函数

    void test()
    {
        cout << "sizeof(Foo)="<<sizeof(Foo) << endl;
        Foo* p = new Foo();
        delete p;

        Foo* pArray = new Foo[];
        delete [] pArray;
    }

下图示侯捷在<<C++内存管理>> 在VC6上的内存管理图片

class A
{
    int a;
    ...
    int j;//共10个int型变量
}

那么这个类的Debug版实际内存应该是下图这种

这个图片分为 白色的上下cookie 上下cookie占8字节 10个灰色的data数据占40字节 12字节的补全字节 和一个橙色的4字节空位,

上面我用的是Qt的编译器

看上面log的第7行 "operator new[].size=64　　return = 0x8714c0" 起始内存点在0x8714c0.但是构造函数的内存起点是0x8714c4

那么这4个字节就是上图白色部分的cookie,它的内存分配应该是下图所示

那么当我们每创建一组这样的数据,那就会有上下两个cookie(8字节),那么当我们创建多组数据的话就会有很多组cookie,那么就会占用一些花销

有一种方法减少这种内存的花销,那就是内存池操作

---

内存池

先说一下内存池的优点

1.减少malloc的使用,提高运行效率

2.可以指定对齐方式

3.减少内存碎片,减少cookie

创建一个Screen类

class Screen
{
public:
    Screen(int x): i(x)
    {
        //todo
    }

    int get()
    {
        return i;
    }

    void* operator new(size_t);
    void operator delete(void*, size_t);

private:
    Screen* next;//4bit
    static Screen* freeStore;
    static const int screenChunk;//想要创建多少组

private:
    int i; //4bit
};

Screen* Screen::freeStore = ;
const int Screen::screenChunk = ;

重载operator new(创建内存池)和operator delete

void* Screen::operator new(size_t size)
{
    Screen* p;
    if(!freeStore)
    {
        //linked list是空的,所以申请一大块内存
        size_t chunk = screenChunk * size; //192 Screen的内存大小为8共24组  24 * 8 = 192
        freeStore = p = reinterpret_cast<Screen*>(new char[chunk]);
        cout << "startPisotion: " << p << endl;

        //将一大块内存分割成片段,当做linked list串接起来
        for(; p != &freeStore[screenChunk-]; ++p)
        {
            p->next = p+;
        }
        p->next = ;
    }
    p = freeStore;
    freeStore = freeStore->next;

    return p;
}

void Screen::operator delete(void* p, size_t)
{
    //将delete object插回 free list前端
    (static_cast<Screen*>(p)) -> next = freeStore;
    freeStore = static_cast<Screen*>(p);
}

测试代码

void test()
{
    cout << sizeof(Screen) << endl;

    size_t const N = ;

    Screen* p[N];

    cout << "overload operator new" << endl;
    for(int i=; i<N; i++)
    {
        p[i] = new Screen(i);
    }

    for(int i = ; i<; i++)
    {
        cout << p[i] << endl;//输出每个Screen的内存起点
    }

    for(int i=; i<N; i++)
    {
        delete p[i];
    }

    cout << "glob operator new" << endl;

    Screen* q[N];

    for(int i=; i<N; i++)
    {
        q[i] = ::new Screen(i);
    }

    for(int i = ; i<; i++)
    {
        cout << q[i] << endl;
    }

    for(int i=; i<N; i++)
    {
        ::delete q[i];
    }
}

测试结果

你会发现调用全局的和调用重载的函数结果差别会很大

全局operator new的默认对齐方式是16字节对齐而且会发现没有了cookie,而且减少了malloc得使用提高使用效率

测试代码

namespace wzj03_class12_15 {

class Screen
{
public:
    Screen(int x): i(x)
    {
        //todo
    }

    int get()
    {
        return i;
    }

    void* operator new(size_t);
    void operator delete(void*, size_t);

private:
    Screen* next;//4bit
    static Screen* freeStore;
    static const int screenChunk;

private:
    int i; //4bit
};

Screen* Screen::freeStore = ;
const int Screen::screenChunk = ;

void* Screen::operator new(size_t size)
{
    Screen* p;
    if(!freeStore)
    {
        //linked list是空的,所以申请一大块内存
        size_t chunk = screenChunk * size; //192 Screen的内存大小为8共24组  24 * 8 = 192
        freeStore = p = reinterpret_cast<Screen*>(new char[chunk]);
        cout << "startPisotion: " << p << endl;

        //将一大块内存分割成片段,当做linked list串接起来
        for(; p != &freeStore[screenChunk-]; ++p)
        {
            p->next = p+;
        }
        p->next = ;
    }
    p = freeStore;
    freeStore = freeStore->next;

    return p;
}

void Screen::operator delete(void* p, size_t)
{
    //将delete object插回 free list前端
    (static_cast<Screen*>(p)) -> next = freeStore;
    freeStore = static_cast<Screen*>(p);
}

void test()
{
    cout << sizeof(Screen) << endl;

    size_t const N = ;

    Screen* p[N];

    cout << "overload operator new" << endl;
    for(int i=; i<N; i++)
    {
        p[i] = new Screen(i);
    }

    for(int i = ; i<; i++)
    {
        cout << p[i] << endl;
    }

    for(int i=; i<N; i++)
    {
        delete p[i];
    }

    cout << "glob operator new" << endl;

    Screen* q[N];

    for(int i=; i<N; i++)
    {
        q[i] = new Screen(i);
    }

    for(int i = ; i<; i++)
    {
        cout << q[i] << endl;
    }

    for(int i=; i<N; i++)
    {
        delete q[i];
    }
}

}

这段代码是封装了一个小型内存池

namespace wzj03_class12_15_1 {
class myAllocator
{
private:
    struct obj
    {
        struct obj* next;
    };

public:
    void* allocate(size_t);
    void  deallocate(void*, size_t);
private:
    obj* freeStore = nullptr;
    const int CHUNK = ;
};

void myAllocator::deallocate(void* p, size_t size)
{
    cout << "myAllocator::deallocate" << "size: " << size <<endl;
    ((obj*)p)->next = freeStore;
    freeStore = (obj*)p;
}

void* myAllocator::allocate(size_t size)
{
    cout << "myAllocator::allocate" << "size: " << size <<endl;
    obj* p;
    if(!freeStore)
    {
        size_t chunk = CHUNK * size;
        freeStore = p = (obj*)malloc(chunk);

        for(int i=; i<(CHUNK-); ++i)
        {
            p->next = (obj*)((char*)p + size);
            p = p->next;
        }

        p->next = nullptr;
    }
    p= freeStore;
    freeStore = freeStore -> next;

    return p;
}

class Foo
{
public:
    long L;
    string str;
    static myAllocator myAlloc;
public:
    Foo(long l): L(l)
    {
       //todo
    }

    static void* operator new(size_t size)
    {
        return myAlloc.allocate(size);
    }

    static void operator delete(void* pdead, size_t size)
    {
        return myAlloc.deallocate(pdead, size);
    }
};
myAllocator Foo::myAlloc;

void test()
{
    cout << sizeof(Foo) << endl;

    size_t const N = ;

    Foo* p[N];

    cout << "overload operator new" << endl;
    for(int i=; i<N; i++)
    {
        p[i] = new Foo(i);
    }

    for(int i = ; i<N; i++)
    {
        cout << p[i] << endl;
    }

    for(int i=; i<N; i++)
    {
        delete p[i];
    }

    cout << "glob operator new" << endl;

    Foo* q[N];

    for(int i=; i<N; i++)
    {
        q[i] = ::new Foo(i);
    }

    for(int i = ; i<N; i++)
    {
        cout << q[i] << endl;
    }

    for(int i=; i<N; i++)
    {
        ::delete q[i];
    }
}

}