析构函数的使用 = 删除；

Question

考虑以下类：

struct S { ~S() = delete; };

简而言之，出于问题的目的：我无法创建 S 的实例，例如 S s{};，因为我无法销毁它们。
正如 cmets 中提到的，我仍然可以通过 S *s = new S; 创建一个实例，但我也不能删除它。
因此，我可以看到删除的析构函数的唯一用途是这样的：

struct S {
    ~S() = delete;
    static void f() { }
};

int main() {
    S::f();
}

也就是说，定义一个只公开一堆静态函数的类，并禁止任何尝试创建该类的实例。

已删除的析构函数还有哪些其他用途（如果有）？

Answer 1

如果您有一个永远不应该成为deleted 或存储在堆栈中（自动存储）或存储为另一个对象的一部分的对象，=delete 将阻止所有这些。

struct Handle {
  ~Handle()=delete;
};

struct Data {
  std::array<char,1024> buffer;
};

struct Bundle: Handle {
  Data data;
};

using bundle_storage = std::aligned_storage_t<sizeof(Bundle), alignof(Bundle)>;

std::size_t bundle_count = 0;
std::array< bundle_storage, 1000 > global_bundles;

Handle* get_bundle() {
  return new ((void*)global_bundles[bundle_count++]) Bundle();
}
void return_bundle( Handle* h ) {
  Assert( h == (void*)global_bundles[bundle_count-1] );
  --bundle_count;
}
char get_char( Handle const* h, std::size_t i ) {
  return static_cast<Bundle*>(h).data[i];
}
void set_char( Handle const* h, std::size_t i, char c ) {
  static_cast<Bundle*>(h).data[i] = c;
}

这里我们有不透明的Handles，它可能不会在堆栈上声明也不会动态分配。我们有一个系统可以从已知数组中获取它们。

我相信以上都不是未定义的行为；未能销毁 Bundle 是可以接受的，在其位置创建一个新的也是可以接受的。

并且界面不必公开Bundle 的工作方式。只是一个不透明的Handle。

现在，如果代码的其他部分需要知道所有句柄都在该特定缓冲区中，或者以特定方式跟踪它们的生命周期，则此技术会很有用。可能这也可以使用私有构造函数和友元工厂函数来处理。

Answer 2

一种情况可能是防止错误释放：

#include <stdlib.h>

struct S {
    ~S() = delete;
};


int main() {

    S* obj= (S*) malloc(sizeof(S));

    // correct
    free(obj);

    // error
    delete obj;

    return 0;

}

这是非常初级的，但适用于任何特殊的分配/解除分配过程（例如工厂）

一个更“c++”风格的例子

struct data {
    //...
};

struct data_protected {
    ~data_protected() = delete;
    data d;
};

struct data_factory {


    ~data_factory() {
        for (data* d : data_container) {
            // this is safe, because no one can call 'delete' on d
            delete d;
        }
    }

    data_protected* createData() {
        data* d = new data();
        data_container.push_back(d);
        return (data_protected*)d;
    }



    std::vector<data*> data_container;
};

Answer 3

为什么将析构函数标记为delete？

当然是为了防止析构函数被调用；）

有哪些用例？

我可以看到至少 3 种不同的用途：

1. 永远不应实例化该类；在这种情况下，我还希望删除默认构造函数。
2. 应该泄露这个类的一个实例；例如，一个日志记录单例实例
3. 此类的实例只能通过特定机制创建和释放；使用 FFI 时尤其会发生这种情况

为了说明后一点，想象一个 C 接口：

struct Handle { /**/ };

Handle* xyz_create();
void xyz_dispose(Handle*);

在 C++ 中，您可能希望将其包装在 unique_ptr 中以自动发布，但如果您不小心写了：unique_ptr<Handle> 怎么办？这是一场运行时灾难！

因此，您可以调整类定义：

struct Handle { /**/ ~Handle() = delete; };

然后编译器将阻塞unique_ptr<Handle>，迫使您正确使用unique_ptr<Handle, xyz_dispose>。

Answer 4

有两个可能的用例。首先（正如一些 cmets 所指出的）动态分配对象是可以接受的，不能delete 它们并允许操作系统在程序结束时进行清理。

或者（甚至更奇怪）您可以分配一个缓冲区并在其中创建一个对象，然后删除该缓冲区以恢复该位置，但从不提示尝试调用析构函数。

#include <iostream>

struct S { 
    const char* mx;

    const char* getx(){return mx;}

    S(const char* px) : mx(px) {}
    ~S() = delete; 
};

int main() {
    char *buffer=new char[sizeof(S)];
    S *s=new(buffer) S("not deleting this...");//Constructs an object of type S in the buffer.
    //Code that uses s...
    std::cout<<s->getx()<<std::endl;

    delete[] buffer;//release memory without requiring destructor call...
    return 0;
}

这些似乎都不是一个好主意，除非是在特殊情况下。如果自动创建的析构函数什么都不做（因为所有成员的析构函数都是微不足道的），那么编译器将创建一个无效的析构函数。

如果自动创建的析构函数会做一些不平凡的事情，您很可能会因未能执行其语义而损害程序的有效性。

让程序离开main() 并允许环境“清理”是一种有效的技术，但最好避免使用，除非限制非常必要。充其量这是掩盖真正内存泄漏的好方法！

我怀疑该功能是为了完整性而存在的，能够delete 其他自动生成的成员。

我希望看到此功能的真正实际应用。

有一个静态类的概念（没有构造函数），因此逻辑上不需要析构函数。但是这样的类更合适地实现为 namespace 在现代 C++ 中没有（好的）位置，除非模板化。

Answer 5

使用new 创建一个对象的实例并且从不删除它是实现 C++ Singleton 的最安全方法，因为它避免了任何和所有破坏顺序问题。这个问题的一个典型例子是在另一个 Singleton 类的析构函数中访问的“Logging”Singleton。 Alexandrescu 曾经在他的经典“现代 C++ 设计”一书中用一整节来讨论如何处理 Singleton 实现中的破坏顺序问题。

删除的析构函数很好，这样即使 Singleton 类本身也不会意外删除实例。它还可以防止像delete &SingletonClass::Instance() 这样的疯狂使用（如果Instance() 返回一个引用，它应该这样做；它没有理由返回一个指针）。

不过，归根结底，这并没有什么值得注意的。当然，你一开始就不应该使用单例。