C++ 重载operator new,delete

new operator 与operator new不是一个概念，new operator作为一个操作符，就是我们常用的new：

Test* ptest = new Test(2);

operator new实质上是一个用来获取内存的函数，实质上调用了malloc

void* operator new(size_t size);

new operator实质上是调用了“operator new函数”+“构造函数”，new operator作为一个操作符，不能重载，而operator new函数与构造函数一样可以被重载。
同理，delete operator实质上是调用了“析构函数”+“operator delete函数(调用的是free)”，重载性质与new一致。
同理，new[]、delete[]规律与上面一致。
验证程序：

#include<iostream>
using namespace std;

class Test
{
	friend ostream& operator <<(ostream& out, Test& test);//重载<<
	int* pa;
public:
	Test(int a = 0)
	{
		pa = new int(a);
		cout << "调用构造函数:" << pa << endl;
	}
	~Test()
	{
		cout << "调用析构函数：" << pa << endl;
		if (pa)
			delete pa;
	}
	Test&operator=(const Test& test)//重载=Test
	{
		if (pa)
			*pa = *(test.pa);
		else
			pa = new int(*(test.pa));
		return *this;
	}
	Test&operator=(int a)//重载=int
	{
		if (pa)
			*pa = a;
		else
			pa = new int(a);
		return *this;
	}
	static void* operator new(size_t size)//重载operator new函数
	{
		void* p = (void*)malloc(size);//调用的是malloc
		cout << "调用重载的 operator new" << endl;
		return p;
	}
	static void operator delete(void* ptest, size_t size)//重载operator delete函数
	{
		cout << "调用重载的operator delete" << endl;
		free(ptest);
	}
	static void* operator new[](size_t size)
	{
		void* p = (void*)malloc(size);
		cout << "调用重载的 operator new[]" << endl;
		return p;
	}
	static void operator delete[](void* ptest, size_t size)
	{
		cout << "调用重载的operator delete[]" << endl;
		free(ptest);
	}
};

ostream& operator <<(ostream& out, Test& test)
{
	out << test.pa << " " << *(test.pa);
	return out;
}

int main()
{
	cout << "new,delete:" << endl;
	Test* ptest = new Test(2);
	cout << *ptest << endl;
	delete ptest;
	cout << "new[],delete[]:" << endl;
	Test* ptest1 = new Test[3];
	for (int i = 0; i < 3; i++)
	{
		ptest1[i] = i + 1;
		cout << ptest1[i] << endl;
	}
		
	delete[] ptest1;
	system("pause");
	return 0;
}

运行结果：

由运行结果来看，new 先调用operator new申请内存，再调用构造函数初始化内存；delete先调用析构函数，再调用operator delete释放内存；new[]与delete[]都只会调用一次operator new[]、operator delete[],且是从前往后构造，从后往前析构。

如果new[]与delete搭配使用，即使用：

delete ptest1;

结果是内存可以正常释放，但是析构函数只会调用第一个，后面的都不会调用。运行结果：