C++语言学习（二十）——自定义内存管理

C++语言学习（二十）——自定义内存管理

一、统计类对象中成员变量的访问次数

mutable是为了突破const函数的限制而设计的，mutable修饰的成员变量将永远处于可改变的状态。mutable成员变量破坏了只读对象的内部状态，而const成员函数保证只读对象的状态不变性，因此mutable成员变量无法保证只读对象状态的不变性。

#include <iostream>

using namespace std;

class Test
{
public:
    Test():m_count(0)
    {
    }
    void setValue(const int value)
    {
        m_count++;
        m_data = value;
    }
    int getValue()
    {
        m_count++;
        return m_data;
    }
    int getValue()const
    {
        m_count++;
        return m_data;
    }
    int getCount()const
    {
        return m_count;
    }
private:
    int m_data;
    mutable int m_count;
};

int main(int argc, char *argv[])
{
    Test test1;
    test1.setValue(100);
    cout << test1.getCount() << endl;

    const Test test2;
    test2.getValue();
    cout << test2.getCount() << endl;
    return 0;
}

上述代码使用mutable修饰成员变量m_count，确保在const函数内部也可以改变其值，但mutable破坏了只读对象状态的不变性，所以不推荐。

#include <iostream>

using namespace std;

class Test
{
public:
    Test():m_count(new int(0))
    {
    }
    void setValue(const int value)
    {
        *m_count = *m_count + 1;
        m_data = value;
    }
    int getValue()
    {
        *m_count = *m_count + 1;
        return m_data;
    }
    int getValue()const
    {
        *m_count = *m_count + 1;
        return m_data;
    }
    int getCount()const
    {
        return *m_count;
    }
private:
    int m_data;
    int*  const m_count;
};

int main(int argc, char *argv[])
{
    Test test1;
    test1.setValue(100);
    cout << test1.getCount() << endl;

    const Test test2;
    test2.getValue();
    cout << test2.getCount() << endl;
    return 0;
}

上述代码使用指针常量统计访问成员变量的次数，不会破坏只读对象的状态不变性。

二、new/delete操作符重载

1、new/delete操作符本质

new/delete的本质是C++预定义的操作符，C++语言规范对new/delete操作符做出了严格的规范：
A、new关键字用于获取足够的内存空间（默认为堆空间），在获取的空间中调用构造函数创建对象。
B、delete调用析构函数销毁对象，归还对象所占用的空间（默认为堆空间）。
C++语言中可以重载new/delete操作符，重载new/delete操作符的意义在于改变动态对象创建时的内存分配方式，可以将new创建的对象分配在栈空间、静态存储空间、指定地址空间。
new/delete操作符支持全局重载、局部重载，但不推荐对new/delete操作符进行全局重载，通常对new/delete操作符进行局部重载，如针对具体的类进行new/delete操作符重载。
new/delete操作符重载函数默认为静态函数，无论是否显示声明static关键字。

    //static member function
    void* operator new(unsigned int size)
    {
        void* ret = NULL;
        /* ret point to allocated memory */
        return ret;
    }
    //static member function
    void operator delete(void* p)
    {
        /* free the memory which is pointed by p */
    }

2、在静态存储区创建对象

#include <iostream>

using namespace std;

class Test
{
private:
    static const unsigned int COUNT = 4;
    static char c_buffer[];
    static char c_map[];
    int m_value;
public:
    Test(int value = 0)
    {
        m_value = value;
        cout << "value : " << value << endl;
    }
    //static member function
    void* operator new (unsigned int size)
    {
        void* ret = NULL;
        for(int i = 0; i < COUNT; i++)
        {
            if( !c_map[i] )
            {
                c_map[i] = 1;
                ret = c_buffer + i * sizeof(Test);
                cout << "succeed to allocate memory: " << ret << endl;
                break;
            }
        }
        return ret;
    }
    //static member function
    void operator delete (void* p)
    {
        if( p != NULL )
        {
            char* mem = reinterpret_cast<char*>(p);
            int index = (mem - c_buffer) / sizeof(Test);
            int flag = (mem - c_buffer) % sizeof(Test);
            if( (flag == 0) && (0 <= index) && (index < COUNT) )
            {
                c_map[index] = 0;
                cout << "succeed to free memory: " << p << endl;
            }
        }
    }
    int getValue()const
    {
        return m_value;
    }
};

char Test::c_buffer[sizeof(Test) * Test::COUNT] = {0};
char Test::c_map[Test::COUNT] = {0};

int main(int argc, char *argv[])
{
    cout << "===== Test Single Object =====" << endl;
    Test* pt = new Test(1);
    delete pt;

    cout << "===== Test Object Array =====" << endl;
    Test* pa[5] = {0};
    for(int i=0; i<5; i++)
    {
        pa[i] = new Test(100 + i);
        cout << "pa[" << i << "] = " << pa[i] << endl;
    }
    for(int i=0; i<5; i++)
    {
        cout << "delete " << pa[i] << endl;
        if(pa[i] != NULL)
        {
            delete pa[i];
        }
    }

    return 0;
}

上述代码，new会创建Test对象到静态存储空间中，从打印结果可以知道new创建Test对象时先调用new操作符重载函数，在返回的空间中再调用Test构造函数。

3、在指定地址创建对象

在类中对new/delete操作符进行重载，在new操作符重载函数中返回指定的地址，在delete操作符重载函数中标记对应的地址可用。

#include <iostream>
#include <string>
#include <cstdlib>

using namespace std;

class Test
{
    static unsigned int c_count;
    static char* c_buffer;
    static char* c_map;
    int m_value;
public:
    static bool SetMemorySource(char* memory, unsigned int size)
    {
        bool ret = false;

        c_count = size / sizeof(Test);

        ret = (c_count && (c_map = reinterpret_cast<char*>(calloc(c_count, sizeof(char)))));

        if( ret )
        {
            c_buffer = memory;
        }
        else
        {
            free(c_map);
            c_map = NULL;
            c_buffer = NULL;
            c_count = 0;
        }
        return ret;
    }

    void* operator new (unsigned int size)
    {
        void* ret = NULL;

        if( c_count > 0 )
        {
            for(int i=0; i<c_count; i++)
            {
                if( !c_map[i] )
                {
                    c_map[i] = 1;
                    ret = c_buffer + i * sizeof(Test);
                    cout << "succeed to allocate memory: " << ret << endl;
                    break;
                }
            }
        }
        else
        {
            ret = malloc(size);
        }

        return ret;
    }

    void operator delete (void* p)
    {
        if( p != NULL )
        {
            if( c_count > 0 )
            {
                char* mem = reinterpret_cast<char*>(p);
                int index = (mem - c_buffer) / sizeof(Test);
                int flag = (mem - c_buffer) % sizeof(Test);
                if( (flag == 0) && (0 <= index) && (index < c_count) )
                {
                    c_map[index] = 0;
                    cout << "succeed to free memory: " << p << endl;
                }
            }
            else
            {
                free(p);
            }
        }
    }
};

unsigned int Test::c_count = 0;
char* Test::c_buffer = NULL;
char* Test::c_map = NULL;

int main(int argc, char *argv[])
{
    char buffer[12] = {0};
    Test::SetMemorySource(buffer, sizeof(buffer));
    cout << "===== Test Single Object =====" << endl;
    Test* pt = new Test;
    delete pt;

    cout << "===== Test Object Array =====" << endl;
    Test* pa[5] = {0};
    for(int i=0; i<5; i++)
    {
        pa[i] = new Test;
        cout << "pa[" << i << "] = " << pa[i] << endl;
    }

    for(int i=0; i<5; i++)
    {
        cout << "delete " << pa[i] << endl;
        delete pa[i];
    }

    return 0;
}

上述代码中，可以在指定地址空间创建对象，也可以不指定地址空间，此时在堆空间创建对象。

4、在栈空间创建对象

#include <iostream>

using namespace std;

class Test
{
    int m_value;
public:
    Test(int value = 0)
    {
        m_value = value;
        cout << "value : " << m_value << endl;
        cout << "this : " << this << endl;
    }
};

int main(int argc, char *argv[])
{
    Test test(100);
    //在栈空间创建对象
    Test* pTest = new(&test) Test(1000);

    return 0;
}
上述代码中，可以使用new操作符的默认实现在栈空间创建对象。

5、new[]/delete[]关键字

new[]/delete[]关键字与new/delete关键字完全不同，是一组全新的关键字。
new[]关键字用于创建动态对象数组，delete[]关键字用于销毁动态对象数组。new[]/delete[]关键字可以进行重载，用于优化内存管理方式。new[]关键字返回的空间大小通常大于预期的动态数组空间大小。

#include <iostream>
#include <string>
#include <cstdlib>

using namespace std;

class Test
{
    int m_value;
public:
    Test(int value = 0)
    {
        m_value = value;
    }

    ~Test()
    {
    }

    void* operator new (unsigned int size)
    {
        cout << "operator new: " << size << endl;
        return malloc(size);
    }

    void operator delete (void* p)
    {
        cout << "operator delete: " << p << endl;
        free(p);
    }

    void* operator new[] (unsigned int size)
    {
        cout << "operator new[]: " << size << endl;
        return malloc(size);
    }

    void operator delete[] (void* p)
    {
        cout << "operator delete[]: " << p << endl;
        free(p);
    }
};

int main(int argc, char *argv[])
{
    Test* pt = NULL;
    pt = new Test;
    delete pt;

    pt = new Test[5];
    delete[] pt;
    return 0;
}

上述代码中，重载了new[]/delete[]关键字。

原文地址：http://blog.51cto.com/9291927/2165138

时间： 2024-11-05 18:32:31

C++语言学习（二十）——自定义内存管理的相关文章

C++语言学习（十二）——C++语言常见函数调用约定

C++语言学习(十二)--C++语言常见函数调用约定 一.C++语言函数调用约定简介 C /C++开发中,程序编译没有问题,但链接的时候报告函数不存在,或程序编译和链接都没有错误,但只要调用库中的函数就会出现堆栈异常等现象.上述现象出现在C和C++的代码混合使用的情况下或在C++程序中使用第三方库(非C++语言开发)的情况下,原因是函数调用约定(Calling Convention)和函数名修饰(Decorated Name)规则导致的.函数调用约定决定函数参数入栈的顺序,以及由调用者函数还是被

C++语言学习（十八）——异常处理

C++语言学习(十八)--异常处理 一.C语言异常处理 异常是指程序在运行过程中产生可预料的执行分支.如除0操作,数组访问越界.要打开的文件不存在.Bug是指程序中的错误,是不被预期的运行方式.如野指针.堆空间使用结束未释放.C语言中处理异常的方式一般是使用if....else...分支语句. double divide(double a, double b) { const double delta = 0.000000000000001; double ret = 0; if( !((-de

菜鸟学习Cocos2d-x 3.x——内存管理

菜鸟学习Cocos2d-x 3.x——内存管理 2014-12-10 分类:Cocos2d-x / 游戏开发 阅读(394) 评论(6) 亘古不变的东西 到现在,内存已经非常便宜,但是也不是可以无限大的让你去使用,特别是在移动端,那么点内存,那么多 APP要抢着用,搞不好,你占的内存太多了,系统直接干掉你的APP,所以说了,我们又要老生常谈了——内存管理.总结COM开发的时候,分析过COM的 内存管理模式:总结Lua的时候,也分析了Lua的内存回收机制:前几天,还专门写了C++中的智能指针在内存

黑 马 程 序 员_视频学习总结&lt;Objective-C&gt;----04 内存管理、protocol、block、ARC

---------------------- ASP.Net+Unity开发..Net培训.期待与您交流! ---------------------- 一.内存管理 1.为什么要用内存管理: 移动设备的内存极其有限,每个app所能占用的内存是有限制的.当app所占用的内存较多时,系统会发出内存警告,这时得回收一些不需要再使用的内存空间.比如回收一些不需要使用的对象.变量等 2.管理范围: 任何继承了NSObject的对象,对其他基本数据类型(int.char.float.double.stru

C++语言学习（十四）——C++类成员函数调用分析

C++语言学习(十四)--C++类成员函数调用分析 一.C++成员函数 1.C++成员函数的编译 C++中的函数在编译时会根据命名空间.类.参数签名等信息进行重新命名,形成新的函数名.函数重命名的过程通过一个特殊的Name Mangling(名字编码)算法来实现.Name Mangling算法是一种可逆的算法,既可以通过现有函数名计算出新函数名,也可以通过新函数名逆向推导出原有函数名.Name Mangling算法可以确保新函数名的唯一性,只要命名空间.所属的类.参数签名等有一个不同,那么产生的

C语言动态分配二维数组内存

C语言内存管理主要包括malloc().remalloc().free()三个函数. malloc原型 extern void *malloc(unsigned int num_bytes); m行n列的 二维数组的分配,主要有三种方法: 一.分配一个长度为m的二级指针,指针的指向的内容分别指向一个长度为n的一位数组 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h>

iOS学习笔记之ARC内存管理

iOS学习笔记之ARC内存管理 写在前面 ARC(Automatic Reference Counting),自动引用计数,是iOS中采用的一种内存管理方式. 指针变量与对象所有权 指针变量暗含了对其所指向对象的所有权 当某个方法(或函数)有一个指向某个对象的局部变量时,可以称该方法(或函数)拥有该变量所指向的对象,如: int main(int argc, const char * argv[]) { @autoreleasepool { // insert code here... NSSt

C++语言学习（十）——继承与派生

C++语言学习(十)--继承与派生 一.类之间的关系 1.类之间的组合关系 组合关系是整体与部分的关系.组合关系的特点:A.将其它类的对象作为当前类的成员使用B.当前类的对象与成员对象的生命周期相同C.成员对象在用法上与普通对象相同Computer类由其它多个部件类组合而成,当Computer销毁时,其它部件对象同时销毁. #include <iostream> using namespace std; class Memory { public: Memory() { cout <&l

C++语言学习（十九）——C++类型识别

C++语言学习(十九)--C++类型识别 一.C++类型识别简介 1.C++类型识别简介 C++是静态类型语言,其数据类型是在编译期就确定的,不能在运行时更改.C++语言中,静态类型是对象自身的类型,动态类型是指针(引用)所指向对象的实际类型.RTTI(Run-Time Type Information)即运行时类型识别,C++通过RTTI实现对多态的支持.为了支持RTTI,C++提供了一个type_info类和typeid与dynamic_cast两个关键字. 2.type_info结构体 t