C++語言學習（二十）——自定義內存管理

時間  2019-11-05
標籤 c++ 語言 學習 二十 自定義 內存 管理 欄目 C&C++ 简体版
原文   原文鏈接

C++語言學習（二十）——自定義內存管理

1、統計類對象中成員變量的訪問次數

mutable是爲了突破const函數的限制而設計的，mutable修飾的成員變量將永遠處於可改變的狀態。mutable成員變量破壞了只讀對象的內部狀態，而const成員函數保證只讀對象的狀態不變性，所以mutable成員變量沒法保證只讀對象狀態的不變性。ios

#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;
}

上述代碼使用指針常量統計訪問成員變量的次數，不會破壞只讀對象的狀態不變性。ide

2、new/delete操做符重載

一、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 */
    }

二、在靜態存儲區建立對象

#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構造函數。學習

三、在指定地址建立對象

在類中對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;
}

上述代碼中，能夠在指定地址空間建立對象，也能夠不指定地址空間，此時在堆空間建立對象。this

四、在棧空間建立對象

#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操做符的默認實如今棧空間建立對象。

五、new[]/delete[]關鍵字

new[]/delete[]關鍵字與new/delete關鍵字徹底不一樣，是一組全新的關鍵字。
new[]關鍵字用於建立動態對象數組，delete[]關鍵字用於銷燬動態對象數組。new[]/delete[]關鍵字能夠進行重載，用於優化內存管理方式。new[]關鍵字返回的空間大小一般大於預期的動態數組空間大小。spa

#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[]關鍵字。設計

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程