C++ 中的 new operator, operator new,placement new

new operator
 string *sp = new string("hello world");
 delete sp;

這里的new稱之為 new operator(new 運算符),它做2件事:

  • 調用的是標準庫函數operator new分配一塊足夠大的,未命名的內存空間。
  • 編譯器運行相應的構造函數在剛才分配的內存上構造對象 , 并返回指向該對象的指針。

這里的delete它做2件事:

  • 調用該對象的析構函數
  • 調用標準庫函數operator delete釋放內存
operator new, operator delete函數
/* 這些版本可能拋出異常 new分配失敗,拋出bad_alloc異常 */
void *operator new(size_t);    
void *operator new[](size_t);
void *operator delete(void*);
void *operator delete[](void*);

/* 下面版本承諾不拋出異常 new分配失敗,不拋出異常,返回nullptr指針 */
void *operator new(size_t, nothrow_t &)  noexcept;    
void *operator new[](size_t, nothrow_t &)  noexcept;
void *operator delete(void*, othrow_t &)  noexcept;
void *operator delete[](void*, othrow_t &)  noexcept;

我們可以在全局或者類里面自定義上面的函數,當我們將其定義成類的成員函數時,它是隱式靜態成員函數。

/* 編寫operator new(分配內存) 和 operator delete(釋放內存)簡單實現方式 */
void* operator new(size_t size) 
{
    if (void *mem = malloc(size))
        return mem;
    else
        throw bad_alloc();
}

void* operator delete() noexcept
{
    free(mem);
}
placement new

上面的 operator new 只是分配內存,而 placement new 不分配內存,只負責在預先分配的內存上構造對象。

new (place_address) type;
new (place_address) type(initializers);
new (place_address) type[size];
new (place_address) type[size]{ braced initializers list };
  • 例子:
string *sp = static_cast<string*>(::operator new(sizeof(string)));  //operator new 分配內存
new (sp) string("hello world");  // placement new 構造對象
    
cout << *sp << endl;
    
sp->~string();    // 主動調用析構函數
::operator delete(sp);  //operator delete 釋放內存
set_new_handler

set_new_handler 是一個"接受一個不接受參數也無返回值的函數"的函數指針,而這個函數就被用來處理bad_alloc異常。( void *operator new(size_t) 或者 void *operator new 分配內存失敗 )。

  • 例子
#include <iostream>     
#include <cstdlib>      
#include <new>

void no_memory() 
{
    std::cout << "Failed to allocate memory!\n";
    std::exit (1);
}

int main() 
{
    std::set_new_handler(no_memory);
    std::cout << "Attempting to allocate 2 GiB..." << std::endl;
    char* p = new char [2 * 1024 * 1024 * 1024];
    std::cout << "ok\n";
    delete[] p;
    return 0;
}
應用:不用工具,實現檢測內存泄漏

整體思路:在申請內存時記錄下該內存的地址和在代碼中申請內存的位置,在內存銷毀時刪除該地址對應的記錄,程序最后統計下還有哪條記錄沒有被刪除,如果還有沒被刪除的記錄就代表有內存泄漏。

  • 重載operator new 函數

    void *operator new(std::size_t size, const char *file, int line);
    void *operator new[](std::size_t size, const char *file, int line);
    
  • 使用宏定義替換new

    #define new new (__FILE__, __LINE__)        // new operator
    
  • 申請內存多申請一段內存記錄元信息

    std::mutex new_output_lock;
    std::mutex new_ptr_lock;
    long long total_mem_alloc = 0;
    new_ptr_list_t new_ptr_list;
    
    void *operator new(std::size_t size, const char *file, int line)
    {
        return alloc_mem(size, file, line, false);
    }
    
    void *operator new[](std::size_t size, const char *file, int line)
    {
        return alloc_mem(size, file, line, true);
    }
    
    static void *alloc_mem(std::size_t size, const char *file, int line, bool is_array)
    {
        assert(line >= 0);
    
        std::size_t s = size + ALIGNED_LIST_ITEM_SIZE;
        new_ptr_list_t *ptr = (new_ptr_list_t *)malloc(s);
        if (ptr == nullptr)
        {
            std::unique_lock<std::mutex> lock(new_output_lock);
            printf("Out of memory when allocating %lu bytes\n", (unsigned long)size);
            abort();
        }
        void *usr_ptr = (char *)ptr + ALIGNED_LIST_ITEM_SIZE;
    
        if (line)
        {
            strncpy(ptr->file, file, DEBUG_NEW_FILENAME_LEN - 1);
            ptr->file[DEBUG_NEW_FILENAME_LEN - 1] = '\0';
        }
        else
        {
            ptr->addr = (void *)file;
        }
    
        ptr->line = line;
        ptr->is_array = is_array;
        ptr->size = size;
        ptr->magic = DEBUG_NEW_MAGIC;
    
        // 鏈表操作
        // 插入鏈表中
    
        total_mem_alloc += size;
    
        return usr_ptr;
    }
    
  • 釋放內存
    鏈表中找到要對應節點,刪除掉,

    void operator delete(void* ptr) noexcept { 
        free_pointer(ptr, nullptr, false); 
    }
    static void free_pointer(void* usr_ptr, void* addr, bool is_array) {
        if (usr_ptr == nullptr) 
        {
            return;
        }
        new_ptr_list_t* ptr = (new_ptr_list_t*)((char*)usr_ptr - ALIGNED_LIST_ITEM_SIZE);
        {
              // 鏈表移除結點操作
        }
        free(ptr);
    }
    
  • 如何檢測是否有內存泄漏?
    遍歷鏈表即可,每次new時候會把這段內存插入鏈表,delete時候會把這段內存從鏈表中移出,如果程序最后鏈表長度不為0,即為有內存泄漏。

  • 沒有被new宏包裹的地方可以檢測的到嗎?
    沒有被new宏包裹的地方是會調用operator new(std::size_t sz)函數來申請內存的。這里operator new函數不只可以重載,還可以重新定義它的實現,因為它是一個weak symbol,有關strong symbol和weak symbol的知識點可以看:強弱符號的問題

    void* operator new(std::size_t size) { 
        return operator new(size, nullptr, 0); 
    }
    

參考資料
1、https://www.zhihu.com/question/29859828/answer/1798470821

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容