为什么要为重载的运算符 new 调用类构造函数？答案

【问题标题】：Why class constructor being called for overloaded operator new?为什么要为重载的运算符 new 调用类构造函数？
【发布时间】：2014-06-16 14:34:24
【问题描述】：

我正在使用 c++11 (g++ v4.7.2)

我已经为“Base”类重载了 operator new 和 operator delete。显然他们不应该在调用 new/delete 时调用构造函数/析构函数，因为我没有在重载的 new/delete 中实现 ctor/dtor 调用。但是输出却相反

//Output of below program
Base new opnd.cpp 87
Base ctor
10
Base dtor
Base delete

为什么要为重载的运算符 new/delete 调用 ctor/dtor？

#include <iostream>

using namespace std;

#define NEW new(__FILE__, __LINE__)
#define DELETE delete

class Base
{
    public:
        Base():m_i(10){ cout << "Base ctor" << endl; }
        virtual ~Base(){ cout << "Base dtor" << endl; }

        void* operator new(size_t size, const char* file, int line) throw(std::bad_alloc);
        void operator delete(void *rawMem, size_t size);

        int geti(){ return m_i; }

    private:
        int m_i;
};

void* Base::operator new(size_t size, const char* file, int line) throw(std::bad_alloc)
{
    void *p;
    cout << "Base new " << file << " " << line << endl;

    //Handle 0 byte requests
    if(size == 0)
        size = 1;

    if(size != sizeof(Base))
    {
        return ::operator new(size);       // To handle new requests for derived classes
    }

    while(true)
    {
        p = malloc(size);

        if(p)
            return p;

        new_handler globalHandler = set_new_handler(0);
        set_new_handler(globalHandler);
        if(globalHandler) (*globalHandler)();
        else throw std::bad_alloc();
    }
}

void Base::operator delete(void *rawMem, size_t size)
{
    cout << "Base delete" << endl;
    if(rawMem == 0)
        return;

    if(size != sizeof(Base))
    {
        ::operator delete(rawMem);     //To handle delete requests for derived classes
        return;
    }

    free(rawMem);
}

int main()
{
   Base *b = NEW Base;
   cout << b->geti() << endl;
   DELETE b;

   return 0;
}

【问题讨论】：

重载 new()/delete 仅用于内存管理。构造函数/析构函数调用是独立完成的。
new/delete 用于分配/解除分配，而不是初始化...
Operator overloading 的可能重复项

标签： c++ operator-overloading

【解决方案1】：

operator new 函数（无论是全局函数还是特定于类的函数）并不是 new 表达式的完整实现。这只是分配功能。当您在代码中写入new T 时，会发生以下情况：

选择并调用名为operator new 的适当分配函数来为对象获取空间。
T的构造函数在点1得到的空间上被调用。

这意味着无法通过编写自己的 operator new 来绕过构造函数调用 - 调用构造函数是由语言完成的，而不是由分配函数完成的。

【讨论】：

【解决方案2】：

'Operator new' 和'new Operator' 是两个不同的东西。当我们使用 new 创建一些对象时，比如

     MyClass* ca= new MyClass();

我们正在使用“新运算符”。它做了两件事：

调用“Operator new”来分配足够的内存。它可以像你一样被重载。
调用对象的构造函数来设置初始化数据。

无论空间如何分配，这两个步骤都会执行。因此，在使用重载的“新运算符”分配内存后，将调用构造函数。

【讨论】：