c++内存泄露检测，长文慎入！

最新推荐文章于 2024-09-13 21:52:35 发布

每天看一遍，防止恋爱&&堕落

最新推荐文章于 2024-09-13 21:52:35 发布

阅读量2.8k

点赞数 4

分类专栏： C、C++ 文章标签： new delete memory c++ c

本文链接：https://blog.csdn.net/zengraoli/article/details/8905334

版权

C、C++ 专栏收录该内容

51 篇文章 5 订阅

订阅专栏

关于内存泄露的，今天无意想到，网上找了一下

本篇blog附带的所有工具和代码下载地址如下：

http://download.csdn.net/detail/zengraoli/5348827

文中的memcheck晚点的时候在把它打包成dll

一、使用Dbgview.exe

不多数都是用的Dbgview.exe，话说还不错，我一直想找的仅仅是一个检测内存泄露的class，没想到csdn上面问，找到了这么一个工具，参看csdn论坛链接http://bbs.csdn.net/topics/390452307

来个测试工程：

#include <iostream>
#include "string"
#include "vector"
using namespace std;

int main()
{
	{
		char *str;
		str = new char[100 + 1];

		strcpy(str, "zengraoli");

		cout << str << endl;
	}

	_CrtDumpMemoryLeaks();   // 内存泄露检测

	return 0;
}

Ctrl+F5后，在Dbgview.exe中出现了下面的信息：

Detected memory leaks

这个是提示

上面的测试不方便的地方：

但在这上面显然有不太好的地方，比如我需要知道哪一行导致的内存泄露，所以参考csdn blog的一篇文章：http://blog.csdn.net/iuhsihsow/article/details/8492363

再次修改：

#include "stdafx.h"
#include <iostream>
#include "string"
#include "vector"
using namespace std;

#ifdef	_DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define newEx   new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

inline void EnableMemLeakCheck()
{
	_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}

int _tmain(int argc, _TCHAR* argv[])
{
	EnableMemLeakCheck();

	char *str = newEx char[9 + 1];

	cout << str << endl;

	return 0;
}

Ctrl+F5后，在Dbgview.exe中出现了下面的信息：

可以看到正是25行的地方导致内存泄露的

二、不使用Dbgview.exe，直接使用class

参考文章：http://www.cnblogs.com/FCoding/archive/2012/07/04/2576877.html

Code没来得及细看，能用就是了^_^，方便就行，枉自猜测一下原理----------重载了new和delete，对他俩进行一个计数，并记下行数，两个不为偶数，则就是代表已经出现内存泄露了

MemCheck.h：

#ifndef MEMCHECK_H
#define MEMCHECK_H
#include <cstddef>  // for size_t

// Hijack the new operator (both scalar and array versions)
void* operator new(std::size_t, const char*, long);
void* operator new[](std::size_t, const char*, long);
#define new new (__FILE__, __LINE__)

extern bool traceFlag;
#define TRACE_ON() traceFlag = true
#define TRACE_OFF() traceFlag = false

extern bool activeFlag;
#define MEM_ON() activeFlag = true
#define MEM_OFF() activeFlag = false

#endif

MemCheck.cpp：

#include <cstdio>
#include <cstdlib>
#include <cassert>
using namespace std;
#undef new

// Global flags set by macros in MemCheck.h
bool traceFlag  = true;
bool activeFlag = false;

namespace 
{
	// Memory map entry type
	struct Info 
	{
		void* ptr;
		const char* file;
		long  line;
	};

	// Memory map data
	const  size_t MAXPTRS = 10000u;
	Info   memMap[MAXPTRS];
	size_t nptrs = 0;

	// Searches the map for an address
	int findPtr(void* p) 
	{
		for (int i = 0; i < nptrs; ++i)
		{
			if (memMap[i].ptr == p)
			{
				return i;
			}
		}
		return -1;
	}

	void delPtr(void* p)
	{
		int pos = findPtr(p);
		assert(p >= 0);
		// Remove pointer from map
		for (size_t i = pos; i < nptrs-1; ++i)
		{
			memMap[i] = memMap[i+1];
		}
		--nptrs;
	}

	// Dummy type for static destructor
	struct Sentinel 
	{
		~Sentinel()
		{
			if (nptrs > 0) 
			{
				printf("Leaked memory at:\n");
				for (size_t i = 0; i < nptrs; ++i)
				{
					printf("\t%p (file: %s, line %ld)\n", 
							memMap[i].ptr, memMap[i].file, memMap[i].line);
				}
			}
			else
			{
				printf("No user memory leaks!\n");
			}				
		}
	};

	// Static dummy object
	Sentinel s;

} // End anonymous namespace

// Overload scalar new
void* operator new(size_t siz, const char* file,
				   long line) 
{
	void* p = malloc(siz);
	if (activeFlag)
	{
		if (nptrs == MAXPTRS)
		{
			printf("memory map too small (increase MAXPTRS)\n");
			exit(1);
		}
		memMap[nptrs].ptr = p;
		memMap[nptrs].file = file;
		memMap[nptrs].line = line;
		++nptrs;
	}
	if (traceFlag) 
	{
		printf("Allocated %u bytes at address %p ", siz, p);
		printf("(file: %s, line: %ld)\n", file, line);
	}
	return p;
}

// Overload array new
void* operator new[](size_t siz, const char* file,
					 long line)
{
	return operator new(siz, file, line);
}

// Override scalar delete
void operator delete(void* p) 
{
	if (findPtr(p) >= 0) 
	{
		free(p);
		assert(nptrs > 0);
		delPtr(p);
		if (traceFlag)
		{
			printf("Deleted memory at address %p\n", p);
		}
	}
	else if (!p && activeFlag)
	{
		printf("Attempt to delete unknown pointer: %p\n", p);
	}	
}

// Override array delete
void operator delete[](void* p)
{
	operator delete(p);
}

那哥们的测试工程，挺不错的，有3种情况：

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <cstring>

#include "MemCheck.h"   // Must appear last!
using namespace std;

void Test()
{
	int *i = new int(0);
}

class MyClass
{
private:
	int *p;
public:
	MyClass()
	{
		if(p != NULL)
		{
			p = new int(0);
		}
	}
	~MyClass()
	{
		if(p != NULL)
		{
			delete p;
			p = NULL;
		}
	}
};

void Test2()
{
	int *i = NULL; 	// better for read
	i = new int(0);    
	int *&y = i; 	// pointer's reference
	delete i;

	MyClass *pMyClass = new MyClass();

	std::vector<MyClass*> myClasses;
	myClasses.push_back(new MyClass());
	myClasses.push_back(new MyClass());

	std::vector<void*> myVector;
	myVector.push_back(new MyClass());
	myVector.push_back(new MyClass());
	delete (MyClass *)(myVector.at(0));
	delete myVector.at(1); // memory leak
}

class Foo 
{
	char* s;
public:
	Foo(const char*s ) 
	{
		this->s = new char[strlen(s) + 1];
		strcpy(this->s, s);
	}
	~Foo() 
	{
		delete [] s;
	}
};

void Test3()
{
	cout << "hello\n";
	int* p = new int;
	delete p;
	int* q = new int[3];
	delete [] q;
	/**//*delete r;*/
	vector<int> v;
	v.push_back(1);
	Foo s("goodbye");
}

int main() 
{
	TRACE_OFF();
	MEM_ON();
	Test();
	Test2();
	Test3();
	MEM_OFF();
}

在我编译的时候，会出现一下提示：