Question

在对象上使用delete运算符通常会导致两件事：调用对象的析构函数（及其虚拟基础析构函数，如果存在）并在之后释放内存。

如果在类上覆盖delete运算符，给它一个空的实现{}，仍然会调用析构函数，但是内存不会被释放。

假设析构函数也是空的，那么delete是否会产生任何影响，或者继续使用“已删除”对象是否安全（即是否存在未定义的行为）？

struct Foo {
    static void operator delete(void* ptr) {}
    Foo() {}
    ~Foo() {}
    void doSomething() { ... }
}

int main() {
    Foo* foo = new Foo();
    delete foo;
    foo->doSomething(); // safe?
}

并不是说这会有多大意义，但我正在研究一种“延迟删除”（gc）机制，在delete被调用但不久之后，对象不会立即被删除。< / p>

更新

参考一些提到内存泄漏的答案：让我们假设重载的delete运算符不为空，但确实将其ptr参数存储在（假设 static 中，为了简单起见）set：

struct Foo {
    static std::unordered_set<void*> deletedFoos;
    static void operator delete(void* ptr) {
        deletedFoos.insert(ptr);
    }
    Foo() {}
    ~Foo() {}
}

此set会定期清理：

for (void* ptr : Foo::deletedFoos) {
    ::operator delete(ptr);
}
Foo::deletedFoos.clear();

Answer 1

来自n4296：

隐式调用析构函数

（11.1） - 对于具有静态存储持续时间（3.7.1）的构造对象   程序终止时（3.6.3），

（11.2） - 对于具有线程存储持续时间（3.7.2）的构造对象   在线程出口处，

（11.3） - 对于具有自动存储持续时间的构造对象   （3.7.3）当创建对象的块退出时（6.7），

（11.4） - 对于构造的临时对象，它的生命周期结束   （12.2）。

在每种情况下，调用的上下文都是上下文   建造物体。还会隐式调用析构函数   通过对构造对象使用delete-expression（5.3.5）   由新表达式分配（5.3.4）;调用的上下文   是delete-expression。 [注意：类类型数组包含   几个子对象，每个子对象都调用析构函数。 -结束   注意]也可以显式调用析构函数。

因此，使用delete表达式调用delete运算符，你也隐式调用析构函数。对象的生命结束了，如果你要为该对象调用一个方法会发生什么不确定的行为。

#include <iostream>

struct Foo {
    static void operator delete(void* ptr) {}
    Foo() {}
    ~Foo() { std::cout << "Destructor called\n"; }
    void doSomething() { std::cout << __PRETTY_FUNCTION__ << " called\n"; }
};

int main() {
    Foo* foo = new Foo();
    delete foo;
    foo->doSomething(); 
   // safe? No, an UB. Object's life is ended by delete expression.
}

输出：

Destructor called
void Foo::doSomething() called

使用：gcc HEAD 8.0.0 20170809 with -O2

问题始于假设重新定义删除操作符和对象的行为将省略对象的破坏。重新定义对象本身的析构函数不会重新定义其字段的析构函数。事实上，从语义学的角度来看，它不再存在。它不会释放内存，如果对象存储在内存池中，这可能是一件事情。但它会删除抽象的灵魂＆＃39;对象，可以说。之后调用方法或访问对象的字段是UB。在特定情况下，取决于操作系统，该存储器可以永久分配。这是一种不安全的行为。假设编译器会生成合理的代码也是不安全的。它可能完全省略了行动。

让我向对象添加一些数据：

struct Foo {
    int a;
    static void operator delete(void* ptr) {}
    Foo(): a(5) {}
    ~Foo() { std::cout << "Destructor called\n"; }
    void doSomething() { std::cout << __PRETTY_FUNCTION__ << "a = " << a << " called\n"; }
};

int main() {
    Foo* foo = new Foo();
    delete foo;
    foo->doSomething(); // safe?
}

输出：

Destructor called
void Foo::doSomething() a= 566406056 called

嗯？我们没有初始化内存？让我们在销毁之前添加相同的电话。

int main() {
    Foo* foo = new Foo();
    foo->doSomething(); // safe!
    delete foo;
    foo->doSomething(); // safe?
}

此处输出：

void Foo::doSomething() a= 5 called
Destructor called
void Foo::doSomething() a= 5 called

什么？当然，编译器在第一种情况下只省略了a的初始化。可能是因为上课没有做其他事吗？在这种情况下，它是可能的。但是这个：

struct Foo {
    int a, b;
    static void operator delete(void* ptr) {}
    Foo(): a(5), b(10) {}
    ~Foo() { std::cout << "Destructor called\n"; }
    void doSomething() { std::cout << __PRETTY_FUNCTION__ << " a= " << a << " called\n"; }
};

int main() {
    Foo* foo = new Foo();
    std::cout << __PRETTY_FUNCTION__ << " b= " << foo->b << "\n"; 
    delete foo;
    foo->doSomething(); // safe?
}

将生成类似的未定义值：

int main() b= 10
Destructor called
void Foo::doSomething() a= 2017741736 called

编译器认为在a死亡时间之前未使用的字段foo因此＆＃34;死了＆＃34;对进一步的代码没有影响。所有＆＃34;双手{＆1 34}下降foo并且它们都不再正式存在。更不用说在Windows上，使用MS编译器，当Foo::doSomething()试图恢复死亡成员时，这些程序可能会崩溃。 Placement new将允许我们扮演Dr.Frankenstein角色：

    #include <iostream>
#include <new>
struct Foo {
    int a;
    static void operator delete(void* ptr) {}
    Foo()              {std::cout << __PRETTY_FUNCTION__ << " a= " << a << " called\n"; }
    Foo(int _a): a(_a) {std::cout << __PRETTY_FUNCTION__ << " a= " << a << " called\n"; }
    ~Foo() { std::cout << "Destructor called\n"; }
    void doSomething() { std::cout << __PRETTY_FUNCTION__ << " a= " << a << " called\n"; }
};

int main() {
    Foo* foo = new Foo(5);
    foo->~Foo(); 

    Foo *revenant = new(foo) Foo();
    revenant->doSomething(); 
}

输出：

Foo::Foo(int) a= 5 called
Destructor called
Foo::Foo() a= 1873730472 called
void Foo::doSomething() a= 1873730472 called

无论如何我们调用析构函数，编译器都可以决定revenant与原始对象不同，所以我们不能重用旧数据，只能分配内存。

奇怪的是，在仍然执行UB的同时，如果我们从Foo删除删除操作符，那么该操作似乎与GCC一样正常工作。在这种情况下我们不会调用delete，但删除和添加它会改变编译器的行为，我相信这是一个实现工件。

Answer 2

来自N4296（~C ++ 14）：

3.8对象生命期[basic.life]

...

类型T的对象的生命周期在以下时间结束：

（1.3） - 如果T是具有非平凡析构函数（12.4）的类类型，则析构函数调用开始，或

（1.4） - 重用或释放对象占用的存储空间。

然后：

12.4析构函数[class.dtor]

...

如果析构函数不是用户提供的，并且如果：
，则析构函数很简单
（5.4） - 析构函数不是virtual，

（5.5） - 其类的所有直接基类都有简单的析构函数，

（5.6） - 对于类的所有类型（或其数组）的非静态数据成员，每个这样的类都有一个简单的析构函数。

否则，析构函数非平凡。

所以基本上，对于足够简单的类，这是安全的，但是如果你涉及任何类型的资源拥有类，它就不合法。

请注意，在您的示例中，您的析构函数是用户提供的，因此非常重要。

Answer 3

你的黑客是否可以工作取决于班级成员。析构函数将始终调用类成员的析构函数。如果你有任何字符串，向量或其他具有“活动”析构函数的对象，那么这些对象将被销毁，即使分配给包含对象的内存仍然很难分配。

Answer 4

主要问题是，即使有空的dtor，也会发生其他背景事件，比如虚拟方法表的发布。在这种情况下，我的个人方法是创建一个私有dtor并使用成员方法（如果需要，可以销毁名称）来过滤删除操作符。例如

class A
{
     bool _may_be_deleted;

public:

    A(bool may_be_deleted)
    : _may_be_deleted(may_be_deleted){;}

    void allow_delete()
    {
        _prevent_delete = false;
    }

    static bool destroy(A*);

private:

    virtual ~A(){;}
};

bool A::destroy(A *pA)
{
    if(pA->_may_be_deleted)
    {
        delete pA;
        return true;
    }
    return false;
}

int main(int argc, char* argv[])
{
    A* pA = new A(false);
    A::destroy(pA);     //returns false and A is not deleted
    pA->allow_delete();
    A::destroy(pA);     //Ok, now A is destroyed and returns true;
}

希望有所帮助。

使用空实现覆盖delete运算符

4 个答案: