18.2 new内存分配细节探秘与重载类内operator new、delete

一：new内存分配细节探秘

我们注意到，一块内存的回收，影响范围很广，远远不止申请的时候的内存大小。

new（malloc）、delete（free）分配内存这个事，绝对不是简单的分配出去一个需要的内存大小，编译器还会在这个内存块周围做很多处理，比如记录分配出去的内存大小等等；

分配内存时，为了记录和管理分配出去的内存你，额外多分配了不少内存，造成了浪费，尤其是频繁的申请小块内存时，造成的浪费更明显，更严重！

#include <iostream>

using namespace std;

namespace nmsp1
{
	void func()
	{
		char* ppoint = new char[10];
		memset(ppoint, 0, 10);
		delete[] ppoint;
		int* ppointInt = new int(10);
		*ppointInt = 2000000000;
		delete ppointInt;
	}
}


int main()
{
	nmsp1::func();
	return 0;
}

二：重载类中的operator new和operator delete操作符

1、在编译器角度看待

new

A *pa = new A(); //操作符
   operator new() //函数
     malloc() //C语言中的malloc()函数
   A::A() //有构造函数就调用

lass A
{
public:
	A()
	{

	};
	~A()
	{

	};
	void* temp = operator new(sizeof(A));
	A* pa = static_cast<A*>(temp);
	pa->A();
};

delete

delete pa;
   A::~A(); //析构函数
   operator delete();
     free() //C语言中的free()函数

class A
{
public:
	A()
	{

	};
	~A()
	{

	};
	void* temp = operator new(sizeof(A));
	A* pa = static_cast<A*>(temp);
	pa->~A();
	operator delete(pa);
};

2、实现operator new和operator delete操作符

#include <iostream>

using namespace std;

class A
{
public:
	A()
	{
		int m_i;
		m_i = 10;
	}
	~A()
	{
		int m_i;
		m_i = 10;
	}

	static void* operator new(size_t size);
	static void operator delete(void* phead);

public:
	//int m_i{20};
};

void* A::operator new(size_t size)
{
	A* ppoint = (A*)malloc(size);
	//A* ppoint = nullptr;
	return ppoint;
}

void A::operator delete(void* phead)
{
	free(phead);
}

void func()
{
	//调用自己编写的operator new和operator delete
	//A* pa1 = new A();
	pa1->m_i = 10;
	//delete pa1;

	//调用系统的operator new和operator delete
	A* pa2 = ::new A();  //::全局操作符
	::delete pa2;
}

int main()
{
	func();
	cout << "end" << endl;
	return 0;
}

三：重载类中的operator new[]和operator delete[]操作符

#include <iostream>

using namespace std;

class A
{
public:
	A()
	{
		int m_i;
		m_i = 10;
	}
	~A()
	{
		int m_i;
		m_i = 10;
	}

	static void* operator new[](size_t size);
	static void operator delete[](void* phead);
};

void* A::operator new[](size_t size)
{
	A* ppoint = (A*)malloc(size);
	return ppoint;
}

void A::operator delete[](void* phead)
{
	free(phead);
}

void func()
{
	//构造和析构函数被调用3次，但是operator new[]和operator delete[]仅仅被调用一次；
	A* pa = new A[3]();
	delete[] pa;
}

int main()
{
	func();
	cout << "end" << endl;
	return 0;
}