C/C++知识点之C++语言学习(二十)——自定义内存管理
小标 2019-03-14 来源 : 阅读 602 评论 0

摘要:本文主要向大家介绍了C/C++知识点之C++语言学习(二十)——自定义内存管理,通过具体的内容向大家展示,希望对大家学习C/C++知识点有所帮助。

本文主要向大家介绍了C/C++知识点之C++语言学习(二十)——自定义内存管理,通过具体的内容向大家展示,希望对大家学习C/C++知识点有所帮助。

C/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[]关键字。

本文由职坐标整理并发布,希望对同学们有所帮助。了解更多详情请关注职坐标编程语言C/C+频道!

本文由 @小标 发布于职坐标。未经许可,禁止转载。
喜欢 | 0 不喜欢 | 0
看完这篇文章有何感觉?已经有0人表态,0%的人喜欢 快给朋友分享吧~
评论(0)
后参与评论

您输入的评论内容中包含违禁敏感词

我知道了

助您圆梦职场 匹配合适岗位
验证码手机号,获得海同独家IT培训资料
选择就业方向:
人工智能物联网
大数据开发/分析
人工智能Python
Java全栈开发
WEB前端+H5

请输入正确的手机号码

请输入正确的验证码

获取验证码

您今天的短信下发次数太多了,明天再试试吧!

提交

我们会在第一时间安排职业规划师联系您!

您也可以联系我们的职业规划师咨询:

小职老师的微信号:z_zhizuobiao
小职老师的微信号:z_zhizuobiao

版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
 沪公网安备 31011502005948号    

©2015 www.zhizuobiao.com All Rights Reserved

208小时内训课程