c++中，我们对new很熟徐了，生成一个动态对象就会调用new，但是，大家真的是知道它的底层运作方式么？
new操作是通过调用new操作符来分配一块内存，类似于malloc的作用，只用通过调用new placement的操作符在这块分配好的内存上调用类的构造函数，返回指向对象的指针。我们下来看看这段代码
#ifndef BASE_H
#define BASE_H
#include <iostream>
using namespace std;
class Base
{
public:
Base()
{
std::cout << "call the Base:Base" << std::endl;
}
};
#endif
//这里模拟operator new 的功能
extern void* func (size_t size);
//base.cpp
#include "base.h"
#include <stdlib.h>
#include <stdio.h>
void* func(size_t size)
{
if(!size)
{
return NULL;
}
return malloc(size);
}
int main()
{
bool ret = false;
do
{
//分配内存
void *ptr = func(sizeof(Base));
if(!ptr)
{
break;
}
//这里是调用了new placement，在ptr指向的内存上调用Base构造
Base *base = new(ptr)(Base);
if(!base)
{
break;
}
ret = true;
delete base;
base = NULL;
}while(false);
return ret ? 0 : 1;
}
通过上面的代码，我们可以了解到整个new 操作符的整个底层调用流程，我们可以重载operator new 函数，来达到自己分配内存的目的，也还有一些其他的妙用，比方说来追中内存的分配和回收情况，来查看系统是否发生内存泄露的情况，这些技巧，下次再补上！
现在，我们来通过重载operator new 和operator delete 来追中内存的泄露情况！先看代码
//func.h
#ifndef FUNC_H
#define FUNC_H
#define DEBUG
#ifdef DEBUG
void *operator new (size_t size,const char *file,size_t line);
void operator delete (void *ptr);
#define Debug_New new(__FILE__,__LINE__)
#else
#define Debug_New new
#endif
#endif
//func.cpp
#include "func.h"
#include <stdlib.h>
#include <stdio.h>
#ifdef DEBUG
//文件名长度
const int FILE_SIZE = 32;
typedef struct Node
{
char file[FILE_SIZE];
size_t line;
size_t size;
Node *next;
}Node;
//Node*的数组长度
const int NODE_lEN = 1024;
//保存每个内存分配信息
static Node* nodeArray[NODE_LEN];
//hash出p处于数组的下标
int hashIndex(void *p)
{
unsigned long val = reinterpret_cast<unsigned long>(p);
return val % NODE_lEN;
}
//向数组插入Node
bool insert(Node *pn,void *p)
{
ret = false;
do
{
if(!pn || !p)
{
break;
}
int hashVal = hashIndex(p);
pn->next = nodeArray[hashVal];
nodeArray[hashVal] = pn;
pn->next = pre;
ret = true;
}while(false);
printf("[分配内存](%s,文件名:%s,行数:%d,大小:%d)\n",(ret ? "成功" :"失败"),pn->file,pn->line,pn->size);
return ret;
}
//向数组删除Node
Node* erase(void *p)
{
Node *ret = NULL;
do
{
int hashVal = hashIndex(p);
Node *pre = nodeArray[hashVal];
if((void*)pre== (p - sizeof(Node))
{
ret = pre;
nodeArray[hashVal] = pre->next;
}
else
{
Node *node = pre->next;
while(node)
{
if(void*)node == (p - sizeof(Node))
{
ret = node;
pre->next = node->next;
break;
}
pre = node;
node = pre->next;
}
}
}while(false);
if(ret)
{
printf("[释放内存](%s,文件名:%s,行数:%d,大小:%d)\n",(true ? "成功" : "失败"),ret->file,ret->line,ret->size);
}
else
{
printf("[释放内存](失败)\n");
}
return ret;
}
//重载new
void* operator new (size_t size,const char *file,size_t line)
{
void *ret = NULL;
bool flg = false;
do
{
if(!size)
{
break;
}
int total = sizeof(Node) + size;
void *pv = std::malloc(total);
Node *pn = (Node*)(pv);
if(!pn)
{
break;
}
strncpy(pn->file,file,sizeof(pn->file)-1);
pn->line = line;
pb->size = size;
pn->next = NULL;
ret = insert(pn,(char*)pv + sizeof(Node)) ? (char*)pv + sizeof(Node) : NULL;
}while(false);
return ret;
}
//重载delete
void operator delete (void* p)
{
void *ret = (void*)erase(p);
free(ret);
}
//base.h
#ifndef BASE_H
#define BASE_H
class Base
{
};
#endif
//main.cpp
#include "base.h"
#include "func.h"
int main()
{
Base *ptr = new Base();
delete ptr;
ptr = NULL;
return 0;
}
我们重载了全局的operator new 和全局的operator delete 函数，通过Node的队列，我们来控制内存，通过日志，我们可以清楚的发现，哪些内存没有被释放。
我把它放git里面了，地址为：https://github.com/flyerSon/practice/tree/master/leak
