自定义内存管理（三）

new[] / delete[] 与 new / delete 有区别吗？

我可以很负责任的告诉你，有区别。
而且 new[] / delete[] 与 new / delete 完全不同。

1. 动态对象数组创建通过 new[] 完成
2. 动态对象数组销毁通过 delete[] 完成
3. new[] / delete[] 可以被重载，进而改变内存管理方式

那他们存在的方式是怎样的？
任然是通过类的静态成员函数进行重载的。

    // static member function
    void* operator new[](unsigned int size)
    {
        return malloc(size);
    }

    // static member function
    void operator delete[](void* p)
    {
        free(p);
    }

注意：

• new[] 实际需要返回的内存空间可能比期望的要多
• 对象数组占用的内存中需要保存数组信息
• 数组信息用于确定构造函数和析构函数的调用

为什么new[] 实际需要返回的内存空间可能比期望的要多?
因为需要额外的空间保存数组信息，比如数组长度，编译器需要替我们自动调用构造函数和析构函数，如果没这个信息，就不知道要调用几次构造和析构了。

#include<iostream>
#include<cstdlib>
using namespace std;

class Test
{
    int m_value;  //32位机上占4字节
public:
    Test() { m_value = 0;}
    ~Test() {}

    // static member function
    void* operator new(unsigned int size)
    {
        cout<<"operator new:"<<size<<endl;
        return malloc(size);
    }

    // static member function
    void operator delete(void* p)
    {
        cout<<"operator delete:"<<p<<endl;
        free(p);
    }

    // static member function
    void* operator new[](unsigned int size)
    {
        cout<<"operator new[]:"<<size<<endl;
        return malloc(size);
    }

    // static member function
    void operator delete[](void* p)
    {
        cout<<"operator delete[]:"<<p<<endl;
        free(p);
    }
};

int main()
{
    Test* pt = NULL;

    pt = new Test();
    delete pt;
    
    pt = new Test[3];
    delete[] pt;

    return 0;
}

运行结果

程序执行到 pt = new Test(); 时调用了 void* operator new(unsigned int size) 的重载版本。
程序执行到 delete pt; 时调用了 void operator delete(void* p) 的重载版本。
程序执行到 pt = new Test[3]; 时调用了void* operator new[](unsigned int size)的重载版本。
程序执行到 delete[] pt; 时调用了 void operator delete[](void* p) 的重载版本。

我们再来看看输出结果，第一行是 4 没啥问题是吧，因为Test对象里有一个 int 类型的成员变量。但是第三行的 16 是怎么回事呢 ？3个 Test 对象一共才 12 个字节呀？为什么会多出来 4 个字节？

其实这多出来的 4 个字节是用来保存数组长度的。

好的，既然这样我们来看看这个代码

#include<iostream>
#include<cstdlib>
using namespace std;

class Test
{
    int m_value;  //32位机上占4字节
public:
    Test() { m_value = 0;}
    ~Test() {}

    // static member function
    void* operator new(unsigned int size)
    {
        cout<<"operator new:"<<size<<endl;
        return malloc(size);
    }

    // static member function
    void operator delete(void* p)
    {
        cout<<"operator delete:"<<p<<endl;
        free(p);
    }

    // static member function
    void* operator new[](unsigned int size)
    {
        cout<<"operator new[]:"<<size<<endl;
        return malloc(size);
    }

    // static member function
    void operator delete[](void* p)
    {
        cout<<"operator delete[]:"<<p<<endl;
        free(p);
    }
};


int main()
{
    Test* pt = NULL;

    //创建一个 Test 对象
    pt = new Test();
    delete pt;

    //这里我也创建一个 Test 对象
    pt = new Test[1];
    delete[] pt;

    return 0;
}

运行结果

我同样是创建一个对象，但是用 new 和 用 new[] 需要分配的 size 却是不同的，由此可见，new 和 new[] 在内存布局上其实是有差异的，他们是不同的啊。这告诫着我们，new / delete 要成对出现 ，new[] / delete[] 也必须成对出现 ，如果混用很可能出现不可挽回的后果。

假如我重载了 new / delete ，让他们在堆中创建对象，重载了new[] / delete[] ，让他们在静态存储区创建对象，如果我 new[] 之后用 delete ，会发生什么？程序会试图将静态存储区的空间归还给堆空间。。。。这是多么可怕的事情啊。

---

1. 不论是 new / delete 还是 new[] / delete[] 其本质都是 C++ 的操作符，我们可以重载他们。
2. 不论是重载 new / delete 还是 new[] / delete[] ，目的都是想要改变其默认的动态内存分配的分配方式。