赞
踩
operator new
(或operator new[]
)的标准库函数, 非配一块足够大, 原始, 未命名的内存空间.operator delete
(或operator delete[]
)的标准库函数释放内存空间.::
(作用域运算符)忽略定义在类中的 new 或 delete 函数. eg: ::new
只在全局作用域中查找.new int
编译器解释为 new(sizeof(int))
.new int[10]
编译器解释为 new(sizeof(int) * 10)
.void *operator new(size_t, void*);
该形式只供标准库使用, 不允许被用户重载.void *operator new(size_t size) {
if (void *mem = malloc(size)) {
return mem;
} else {
throw bad_alloc();
}
}
void operator delete(void mem) noexcept {
free(mem);
}
- MemInfoNode 用于记录申请的一块内存的信息. MemList 为一个单项链表, 存储每个申请的内存块的数据.
#define new new(__FILE__, __LINE__)
的作用是, 可以在代码中直接方便的使用 new, 不改变原来代码中的语法. eg:new int
将替换为new(__FILE__, __LINE__) int
. 编译器最后将调用operator new(sizeof(int), __FILE__, __LINE__)
函数.- 在 MemList 中要使用 malloc 和 free. 防止使用 new, delete 造成的递归死循环.
#include <iostream>
using namespace std;
class MemInfoNode {
private:
void *pMem = NULL; //memory address
size_t memSize = 0;
const char *codeFile = NULL;
unsigned int codeLine = 0;
MemInfoNode *pNext = NULL; //point to next node
void Print(ostream &out = std::cout) {
out << " FileName: " << codeFile
<< " LineNum: " << codeLine
<< " MemAddr: " << pMem
<< " MemSize: " << memSize
<< std::endl;
}
friend class MemList;
};
class MemList {
public:
MemList() {}
~MemList() {
MemInfoNode *nTmp = NULL;
//释放泄露内存
while (m_pHeadNode) {
if (m_pHeadNode->pMem) {
free(m_pHeadNode->pMem);
}
// move to next node
nTmp = m_pHeadNode->pNext;
free(m_pHeadNode);
m_pHeadNode = nTmp->pNext;
}
}
bool Prepend(void *pMem, size_t memSize, const char *fileName, unsigned int lineNo) {
if (!pMem) {
return false;
}
MemInfoNode *pNode = (MemInfoNode*)malloc(sizeof(MemInfoNode));
pNode->pMem = pMem; pNode->memSize = memSize; pNode->codeFile = fileName; pNode->codeLine = lineNo;
pNode->pNext = m_pHeadNode; m_pHeadNode = pNode;
return true;
}
bool Remove(void *ptr) {
if (!ptr) {
return false;
}
MemInfoNode *n_pIt = m_pHeadNode;
MemInfoNode *n_pPtr = NULL;
while (n_pIt) {
if (n_pIt->pMem == ptr) { //findIt
// 从 list 中 remove node
if (!n_pPtr) {
m_pHeadNode = n_pIt->pNext;
}
else {
n_pPtr->pNext = n_pIt->pNext;
}
// free node
free(n_pIt);
return true;
}
n_pPtr = n_pIt;
n_pIt = n_pIt->pNext;
}
return false;
}
friend ostream & operator << (ostream &out, MemList obj);
void Result(ostream &out = std::cout) {
if (!m_pHeadNode) {
out << "[OK] This Application no memory leak!" << std::endl;
}
else {
out << "[ERR] This Application have memory leak!" << std::endl;
MemInfoNode *n_pIt = m_pHeadNode;
while (n_pIt) {
n_pIt->Print(out);
n_pIt = n_pIt->pNext;
}
}
}
private:
MemInfoNode *m_pHeadNode = NULL;
};
ostream & operator << (ostream &out, MemList obj) {
obj.Result(out);
return out;
}
/*--------------- 全局变量 ------------------*/
MemList mem_list;
/*-------------- 重载 new new[] delete delete[] ---------------*/
void *operator new(size_t size, const char *fileName, unsigned int lineNo){
void *pMem = malloc(size);
if (pMem) {
mem_list.Prepend(pMem, size, fileName, lineNo);
}
return pMem;
}
void *operator new[](size_t size, const char *fileName, unsigned int lineNo){
return operator new(size, fileName, lineNo); //Tips: 不能用 new, 而应该用 operator new
}
void operator delete(void *pMem) {
if (pMem) {
free(pMem);
mem_list.Remove(pMem);
}
}
void operator delete[](void *pMem) {
operator delete(pMem);
}
/*------------------ 将 new 替换为重载的 new ----------------*/
#define new new(__FILE__, __LINE__)
void Test_bad_code() {
int *p1 = new int;
int *p2 = new int;
int *p3 = new int[10];
int *p4 = new int[20];
delete p1;
delete []p3;
}
void Test_good_code() {
int *p1 = new int;
int *p2 = new int;
int *p3 = new int[10];
int *p4 = new int[20];
delete p1;
delete p2;
delete []p3;
delete []p4;
}
int main()
{
Test_good_code();
Test_bad_code();
//cout << mem_list;
mem_list.Result();
int tmp;
cin >> tmp;
return 1;
}

Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。