C++中重载new和delete的使用
某些应用程序对内存分配有特殊的需求，因此我们无法将标准内存管理机制直接应用于这些程序。它们常常需要自定义内存分配的细节，比如使用关键字new将对象放置在特定的内存空间中。为了实现这一目的，应用程序需要重载new运算符和delete运算符以控制内存分配的过程。
尽管能够”重载new和delete”，但是实际上重载这两个运算符与重载其它运算符的过程大不相同。要想真正掌握重载new和delete的方法，首先要对new表达式和delete表达式的工作机理有更多的了解。
当我们使用一条new表达式时：
string* sp = new string("a value"); // 分配并初始化一个string对象
string* arr = new string[10]; // 分配10个默认初始化的string对象当我们使用一条delete表达式删除一个动态分配的对象时：
delete sp; // 销毁*sp,然后释放sp指向的内存空间
delete[] arr; // 销毁数组中的元素，然后释放对应的内存空间如果应用程序希望控制内存分配的过程，则它们需要定义自己的operator new函数和operator delete函数。即使在标准库中已经存在这两个函数的定义，我们仍旧可以定义自己的版本。编译器不会对这种重复的定义提出异议，相反，编译器将使用我们自定义的版本替换标准库定义的版本。
当定义了全局operator new函数和operator delete函数后，我们就担负起了控制动态内存分配的职责。这两个函数必须是正确的：因为它们是程序整个处理过程中至关重要的一部分。
应用程序可以在全局作用域中定义operator new函数和operator delete函数，也可以将它们定义为成员函数。当编译器发现一条new表达式或delete表达式后，将在程序中查找可供调用的operator函数。如果被分配(释放)的对象是类类型，则编译器首先在类及其基类的作用域中查找。此时如果该类含有operator new成员或operator delete成员，则相应的表达式将调用这些成员。否则，编译器在全局作用域查找匹配的函数。此时如果编译器找到了用户自定义的版本，则使用该版本执行new表达式或delete表达式；如果没找到，则使用标准库定义的版本。
我们可以使用作用域运算符令new表达式或delete表达式忽略定义在类中的函数，直接执行全局作用域中的版本。例如，::new只在全局作用域中查找匹配的operator new函数，::delete与之类似。
标准库定义了operatornew函数和operator delete函数的8个重载版本。其中前4个版本可能抛出bad_alloc异常，后4个版本则不会抛出异常：
//这些版本可能抛出异常
void* operator new(size_t); // 分配一个对象
void* operator new[] (size_t); // 分配一个数组
void* operator delete(void*) noexcept; // 释放一个对象
void* operator delete[] (void*) noexcept; //释放一个数组void* operator new(size_t, nothrow_t&) noexcept;
void* operator new[](size_t, nothrow_t&) noexcept;
void* operator delete(void*, nothrow_t&) noexcept;
void* operator delete[] (void*, nothrow_t&) noexcept;应用程序可以自定义上面函数版本中的任意一个，前提是自定义的版本必须位于全局作用域或者类作用域中。当我们将上述运算符函数定义成类的成员时，它们是隐式静态的。我们无需显示地声明static，当然这么做也不会引发错误。因为operator new用在对象构造之前而operator delete用在对象销毁之后，所以这两个成员(new和delete)必须是静态的，而且它们不能操作类的任何数据成员。
对于operator new函数或者operator new[]函数来说，它的返回类型必须是void*,第一个形参的类型必须是size_t且该形参不能含有默认实参。当我们为一个对象分配空间时使用operator new；为一个数组分配空间时使用operator new[]。当编译器调用operator new时，把存储指定类型对象所需的字节数传给size_t形参；当调用operator new[]时，传入函数的则是存储数组中所有元素所需的空间。
如果我们想要定义operator new函数，则可以为它提供额外的形参。此时，用到这些自定义函数的new表达式必须使用new的定位形式将实参传给新增的形参。尽管在一般情况下我们可以自定义具有任何形参的operator new，但是下面这个函数却无论如何不能被用户重载：
void* operator new(size_t, void*); // 不允许重新定义这个版本这种形式只供标准库使用，不能被用户重新定义。
对于operator delete函数或者operator delete[]函数来说，它们的返回类型必须是void，第一个形参的类型必须是void*。执行一条delete表达式将调用相应的operator函数，并用指向待释放内存的指针来初始化void*形参。
当我们将operator delete或operator delete[]定义成类的成员时，该函数可以包含另外一个类型为size_t的形参。此时，该形参的初始值是第一个形参所指对象的字节数。size_t形参可用于删除继承体系中的对象。如果基类有一个虚析构函数，则传递给operator delete的字节数将因待删除指针所指对象的动态类型不同而有所区别。而且，实际运行的operator delete函数版本也由对象的动态类型决定。
new表达式与operator new函数：标准库函数operator new和operator delete的名字容易让人误解。和其它operator函数不同(比如operator =)，这两个函数并没有重载new表达式或delete表达式。实际上，我们根本无法自定义new表达式或delete表达式的行为。一条new表达式的执行过程总是先调用operator new函数以获取内存空间，然后在得到的内存空间中构造对象。与之相反，一条delete表达式的执行过程总是先销毁对象，然后调用operator delete函数释放对象所占的空间。我们提供新的operator new函数和operator delete函数的目的在于改变内存分配的方式，但是不管怎样，我们都不能改变new运算符和delete运算符的基本含义。
malloc函数与free函数：malloc函数接受一个表示待分配字节数的size_t，返回指向分配空间的指针或者返回0以表示分配失败。free函数接受一个void*，它是malloc返回的指针的副本，free将相关内存返回给系统。调用free(0)没有任何意义。
定位new表达式：尽管operator new函数和operator delete函数一般用于new表达式，然而它们毕竟是标准库的两个普通函数，因此普通的代码也可以直接调用它们。在C++的早期版本中，allocator类还不是标准库的一部分。应用程序如果想把内存分配与初始化分离开来的话，需要调用operator new和operator delete。这两个函数的行为与allocator的allocate成员和deallocate成员非常类似，它们负责分配或释放内存空间，但是不会构造或销毁对象。
与allocator不同的是，对于operator new分配的内存空间来说我们无法使用construct函数构造对象。相反，我们应该使用new的定位new (placement new)形式构造对象。如我们所知，new的这种形式为分配函数提供了额外的信息。我们可以使用定位new传递一个地址，此时定位new的形式如下所示：
new(place_address) type
new(place_address) type (initializers)
new(place_address) type [size]
new(place_address) type [size] { braced initializer list }当仅通过一个地址值调用时，定位new使用operator new(size_t, void*)”分配”它的内存。这是一个我们无法自定义的operator new版本。该函数不分配任何内存，它只是简单地返回指针实参；然后由new表达式负责在指定的地址初始化对象以完成整个工作。事实上，定位new允许我们在一个特定的、预先分配的内存地址上构造对象。当只传入一个指针类型的实参时，定位new表达式构造对象但是不分配内存。
尽管在很多时候使用定位new与allocator的construct成员非常相似，但在它们之间也有一个重要的区别。我们传给construct的指针必须指向同一个allocator对象分配的空间，但是传给定位new的指针无需指向operator new分配的内存。实际上传给定位new表达式的指针甚至不需要指向动态内存。
显示的析构函数调用：就像定位new与使用allocate类似一样，对析构函数的显示调用也与使用destroy很类似。我们既可以通过对象调用析构函数，也可以通过对象的指针或引用调用析构函数，这与调用其它成员函数没什么区别：
string* sp = new string("a value"); // 分配并初始化一个string对象
sp->~string()The new and delete operators can also be overloaded like other operators in C++. New and Delete operators can be overloaded globally or they can be overloaded for specific classes.
If these operators are overloaded using member function for a class, it means that these operators are overloaded only for that specific class.
If overloading is done outside a class (i.e. it is not a member function of a class), the overloaded ‘new’ and ‘delete’ will be called anytime you make use of these operators (within classes or outside classes). This is global overloading.
以上内容主要摘自：《C++Primer(Fifth Edition 中文版)》第19.1章节
关于其它operator函数的使用可以参考： http://blog.csdn.net/fengbingchun/article/details/51292506
下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：
#include "operator_new.hpp"
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <string>
namespace operator_new_ {
// reference: http://zh.cppreference.com/w/cpp/memory/new/operator_new
class New1 {
public:
New1() = default;
void* operator new(std::size_t sz){
std::printf("global op new called, size = %zu\n", sz);
return std::malloc(sz);
}
void operator delete(void* ptr) /*noexcept*/
{
std::puts("global op delete called");
std::free(ptr);
}
};
struct New2 {
static void* operator new(std::size_t sz)
{
std::cout << "custom new for size " << sz << '\n';
return ::operator new(sz);
}
static void* operator new[](std::size_t sz)
{
std::cout << "custom new for size " << sz << '\n';
return ::operator new(sz);
}
static void operator delete(void* ptr, std::size_t sz)
{
std::cout << "custom delete for size " << sz << '\n';
::operator delete(ptr);
}
static void operator delete[](void* ptr, std::size_t sz)
{
std::cout << "custom delete for size " << sz << '\n';
::operator delete(ptr);
}
};
struct New3 {
New3() { throw std::runtime_error(""); }
static void* operator new(std::size_t sz, bool b){
std::cout << "custom placement new called, b = " << b << '\n';
return ::operator new(sz);
}
static void operator delete(void* ptr, bool b)
{
std::cout << "custom placement delete called, b = " << b << '\n';
::operator delete(ptr);
}
};
int test_operator_new_1()
{
New1* new1 = new New1;
delete new1;
New2* p1 = new New2;
delete p1;
New2* p2 = new New2[10];
delete[] p2;
try {
New3* p1 = new (true) New3;
} catch (const std::exception&) {}
return 0;
}
///
// https://www.geeksforgeeks.org/overloading-new-delete-operator-c/
class student
{
std::string name;
int age;
public:
student()
{
std::cout << "Constructor is called\n";
}
student(std::string name, int age)
{
std::cout << "Constructor params is called\n";
this->name = name;
this->age = age;
}
void display()
{
std::cout << "Name:" << name << std::endl;
std::cout << "Age:" << age << std::endl;
}
void * operator new(size_t size)
{
std::cout << "Overloading new operator with size: " << size << std::endl;
void * p = ::new student();
//void * p = malloc(size); will also work fine
return p;
}
void operator delete(void * p)
{
std::cout << "Overloading delete operator " << std::endl;
free(p);
}
};
int test_operator_new_2()
{
student * p = new student("Yash", 24);
p->display();
delete p;
return 0;
}
// reference: http://thispointer.com/overloading-new-and-delete-operators-at-global-and-class-level/
class Dummy
{
public:
Dummy()
{
std::cout << "Dummy :: Constructor" << std::endl;
}
~Dummy()
{
std::cout << "Dummy :: Destructor" << std::endl;
}
// Overloading CLass specific new operator
static void* operator new(size_t sz)
{
void* m = malloc(sz);
std::cout << "Dummy :: Operator new" << std::endl;
return m;
}
// Overloading CLass specific delete operator
static void operator delete(void* m)
{
std::cout << "Dummy :: Operator delete" << std::endl;
free(m);
}
};
int test_operator_new_3()
{
Dummy * dummyPtr = new Dummy;
delete dummyPtr;
return 0;
}
//
// reference: https://msdn.microsoft.com/en-us/library/kftdy56f.aspx
class Blanks
{
public:
Blanks() { std::cout << "Constructor " << std::endl; }
void* operator new(size_t stAllocateBlock, char chInit);
};
void* Blanks::operator new(size_t stAllocateBlock, char chInit)
{
std::cout << "size:" << stAllocateBlock << ",chInit:" << chInit << "end" << std::endl;
void *pvTemp = malloc(stAllocateBlock);
if (pvTemp != 0)
memset(pvTemp, chInit, stAllocateBlock);
return pvTemp;
}
int test_operator_new_4()
{
Blanks *a5 = new(0xa5) Blanks;
std::cout << (a5 != 0) << std::endl;
return 0;
}
// reference: http://www.interviewsansar.com/2015/07/15/write-syntax-to-overload-new-and-delete-operator-in-a-class/
class CustomMemory {
private:
int i; // size of int is 4 byte
public:
CustomMemory(){
std::cout << "Constructor" << "\n";
}
~CustomMemory(){
std::cout << "Destructor" << "\n";
}
//Overloaded new
void* operator new(size_t objectSize)
{
std::cout << "Custom memory allocation" << "\n";
//Write allocation algorithm here
return malloc(objectSize);
}
//Overloaded 2 arguments new operator
void* operator new(size_t objectSize, int x)
{
std::cout << "Custom 2 argument memory allocation" << "\n";
CustomMemory *ptr = (CustomMemory*)malloc(objectSize);
ptr->i = x;
return ptr;
}
//Overloaded delete
void operator delete(void* ptr)
{
std::cout << "Custom memory de- allocation" << "\n";
free(ptr);
}
void Display()
{
std::cout << "Value of i =" << i << "\n";
}
};
int test_operator_new_5()
{
CustomMemory* obj = new CustomMemory(); // call overloaded new from the class delete obj;
delete obj; // call overloaded delete
//overloaded 2 argument new
CustomMemory * ptr = new(5)CustomMemory();
ptr->Display();
delete ptr;
return 0;
}
} // namespace operator_new_GitHub： https://github.com/fengbingchun/Messy_Test