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