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
