如何创建和使用带有智能指针的singleton模式

Question

单例实现中哪一种更好，优点和缺点是什么？

//第一个

class singleton_SharedPtr{
public:
singleton_SharedPtr(const singleton_SharedPtr&) = delete;
singleton_SharedPtr& operator=(const singleton_SharedPtr&) = delete;
~singleton_SharedPtr(){}
//is it normal to return weak_ptr instead of share_ptr in the getInstance method????
static std::shared_ptr<int> getInstance(){
std::cout<<"referenced before if condfition, use_count : "<<instance.use_count()<<std::endl;
if(instance==nullptr){
instance=std::make_shared<int>();
}
std::cout<<"referenced after if condfition, use_count : "<<instance.use_count()<<std::endl;
return instance;
}
private:
singleton_SharedPtr(){}
static std::shared_ptr<int> instance;
};
std::shared_ptr<int> singleton_SharedPtr::instance=nullptr;

//第二

class singleton_UniquePtr{
public:
singleton_UniquePtr(const singleton_UniquePtr&) = delete;
singleton_UniquePtr& operator=(const singleton_UniquePtr&) = delete;
~singleton_UniquePtr(){}
static int* getInstance(){
if(instance==nullptr){
instance=std::make_unique<int>();
}else
std::cout<<"instance.get: "<<instance.get()<<std::endl;
return instance.get();
}
private:
singleton_UniquePtr(){}
static std::unique_ptr<int> instance;
};
std::unique_ptr<int> singleton_UniquePtr::instance=nullptr;

我们需要访问循环中的实例。内存泄漏会不会发生？如果是，它们中的哪一个导致内存泄漏。

//1:
while(1){std::shared_ptr<int>sharedPtr=
singleton_SharedPtr::getInstance();
//use sharePtr...
//...
}
//2:
while(1){
std::weak_ptr<int>weakPtr=singleton_SharedPtr::getInstance();
//use sharePtr...
//...
}

//3:
while(1){
int* rawPtr=singleton_UniquePtr::getInstance();
//use rawPtr...
//...
if(rawPtr){
delete rawPtr;
rawPtr=nullptr;
}
}

关于性能、内存泄漏、标准化和……的细节，有什么建议吗？非常感谢。

Answer 1

不要使用智能指针创建单例。我会说使用

class Singleton {
public:
static public Singleton* instance() {
static Singleton* s_instance = new Singleton();
return s_instance();
}
private:
Singleton() {}
};

指针永远不会被删除，但由于它只创建一次，并且持续整个程序长度，这应该不是问题。任何在关闭时清理的东西都可能导致依赖性地狱，这会更糟。智能指针对singleton实例没有意义，因为所有权是全局静态空间。智能指针是为了强制执行清晰的指针所有权，在这种情况下这不是问题。