具有使用 std::unique_ptr 的私有析构函数的单例

Singleton with private destructor using std::unique_ptr

本文关键字：析构函数 单例 ptr unique std      更新时间：2023-10-16

我已经在我的程序中创建了所有单例，并牢记该文档：http://erdani.com/publications/DDJ_Jul_Aug_2004_revised.pdf(如果有人想知道为什么是 Singleton，它们都是工厂，其中一些存储了一些关于它们应该如何创建实例的全局设置(。

它们中的每一个看起来都像这样：

声明：

class SingletonAndFactory {
    static SingletonAndFactory* volatile instance;
public:
    static SingletonAndFactory& getInstance();
private:
    SingletonAndFactory();
    SingletonAndFactory(
        const SingletonAndFactory& ingletonFactory
    );
    ~SingletonAndFactory();
};

定义：

boost::mutex singletonAndFactoryMutex;
////////////////////////////////////////////////////////////////////////////////
// class SingletonAndFactory {
SingletonAndFactory* volatile singletonAndFactory::instance = 0;
// public:
SingletonAndFactory& SingletonAndFactory::getInstance() {
    // Singleton implemented according to:
    // "C++ and the Perils of Double-Checked Locking".
    if (!instance) {
        boost::mutex::scoped_lock lock(SingletonAndFactoryMutex);
        if (!instance) {
            SingletonAndFactory* volatile tmp = (SingletonAndFactory*) malloc(sizeof(SingletonAndFactory));
            new (tmp) SingletonAndFactory; // placement new
            instance = tmp;
        }
    }
    return *instance;
}
// private:
SingletonAndFactory::SingletonAndFactory() {}
// };

撇开单例设计是最好的问题(因为它会引发一场毫无意义的火焰战(，我的问题是：用 std：：unique_ptr 替换普通指针对我有益吗？特别是，它会在程序退出时调用单例析构函数吗？如果是这样，我将如何实现它？当我尝试添加类似friend class std::unique_ptr<SingletonAndFactory>;的东西时，它没有成功，因为编译器一直抱怨析构函数是私有的。

我知道这在我目前的项目中并不重要，因为没有一家工厂需要任何形式的清洁，但为了将来参考，我想知道如何实现这种行为。

删除的不是unique_ptr本身，而是删除器。因此，如果您想采用friend方法，则必须这样做：

friend std::unique_ptr<SingletonFactory>::deleter_type;

但是，我认为不能保证默认删除器不会将实际delete委托给另一个函数，这会破坏这一点。

相反，您可能希望提供自己的删除器，如下所示：

class SingletonFactory {
    static std::unique_ptr<SingletonFactory, void (*)(SingletonFactory*)> volatile instance;
public:
    static SingletonFactory& getInstance();
private:
    SingletonFactory();
    SingletonFactory(
        const SingletonFactory& ingletonFactory
    );
    ~SingletonFactory();
    void deleter(SingletonFactory *d) { d->~SingletonFactory(); free(d); }
};

在创建功能中：

SingletonFactory* volatile tmp = (SingletonFactory*) malloc(sizeof(SingletonFactory));
new (tmp) SingletonFactory; // placement new
instance = decltype(instance)(tmp, &deleter);

在 C++11 中，您可以使用本地静态文件保证程序结束时线程安全的延迟初始化和销毁：

SingletonAndFactory& SingletonAndFactory::getInstance() {
    static SingletonAndFactory instance;
    return instance;
}

请注意，这仍可能导致生存期问题，因为它可能会在其他静态对象之前被销毁。如果他们试图从他们的析构函数访问它，那么你将有麻烦。

在此之前，这是不可能的(尽管许多编译器保证了上述内容(。如您链接到的文档中所述，volatile与线程同步无关，因此您的代码具有数据争用和未定义的行为。选项包括：

    以
  • 锁定的(潜在大(性能影响为例，以检查指针
  • 使用编译器提供的任何不可移植的原子内部函数来测试指针
  • 忘记线程安全初始化，并确保在启动线程之前已初始化
  • 不要使用单例

我赞成最后一个选项，因为它解决了单例反模式引入的所有其他问题。

相关文章：