最近，我遇到了C++的Singleton设计模式的实现/实现。它看起来是这样的（我采用了现实生活中的例子）：
// a lot of methods are omitted here
class Singleton
{
public:
static Singleton* getInstance( );
~Singleton( );
private:
Singleton( );
static Singleton* instance;
};
从这个声明中，我可以推断实例字段是在堆上启动的。这意味着存在内存分配。对我来说完全不清楚的是，内存将在何时被释放？或者是否存在错误和内存泄漏？似乎在实现方面存在问题。
我的主要问题是，如何以正确的方式实现它？
当前回答
它将类的实例化限制为一个对象。当只需要一个对象来协调整个系统的操作时，这非常有用
class Singleton {
private:
int data;
static Singleton* instance;
Singleton();
public:
static Singleton* getInstance();
};
Singleton* Singleton::instance = 0;
Singleton::Singleton()
{
this->data = 0;
cout << "constructor called.." << endl;
}
Singleton* Singleton::getInstance() {
if (!instance) {
instance = new Singleton();
return instance;
}
}
int main() {
Singleton *s = s->getInstance();
Singleton *s1 =s1->getInstance();
}
其他回答
我没有在答案中找到CRTP实现，所以这里是：
template<typename HeirT>
class Singleton
{
public:
Singleton() = delete;
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
static HeirT &instance()
{
static HeirT instance;
return instance;
}
};
要使用，只需从此继承类，例如：class Test:public Singleton＜Test＞
这是关于对象生命周期管理的。假设您的软件中有多个单体。它们依赖于Logger单例。在应用程序销毁期间，假设另一个单例对象使用Logger记录其销毁步骤。您必须保证Logger应该最后清理。因此，请同时查看本文：http://www.cs.wustl.edu/~schmidt/PDF/ObjMan.PDF
除了这里的其他讨论之外，可能值得注意的是，您可以使用全局性，而不限于一个实例。例如，考虑引用计数的情况。。。
struct Store{
std::array<Something, 1024> data;
size_t get(size_t idx){ /* ... */ }
void incr_ref(size_t idx){ /* ... */}
void decr_ref(size_t idx){ /* ... */}
};
template<Store* store_p>
struct ItemRef{
size_t idx;
auto get(){ return store_p->get(idx); };
ItemRef() { store_p->incr_ref(idx); };
~ItemRef() { store_p->decr_ref(idx); };
};
Store store1_g;
Store store2_g; // we don't restrict the number of global Store instances
现在，在函数（如main）中的某个位置，您可以执行以下操作：
auto ref1_a = ItemRef<&store1_g>(101);
auto ref2_a = ItemRef<&store2_g>(201);
ref不需要将指针存储回各自的store，因为这些信息是在编译时提供的。您也不必担心Store的生存期，因为编译器要求它是全局的。如果确实只有一个Store实例，那么这种方法没有开销；在不止一个实例的情况下，编译器需要对代码生成进行巧妙处理。如果需要，ItemRef类甚至可以成为Store的朋友（您可以有模板朋友！）。
如果Store本身是一个模板化的类，那么事情就变得更糟了，但是仍然可以使用这个方法，也许可以通过实现具有以下签名的helper类：
template <typename Store_t, Store_t* store_p>
struct StoreWrapper{ /* stuff to access store_p, e.g. methods returning
instances of ItemRef<Store_t, store_p>. */ };
用户现在可以为每个全局Store实例创建StoreWrapper类型（和全局实例），并始终通过其包装器实例访问商店（从而忘记使用Store所需的模板参数的详细信息）。
我的实现与Galik的类似。不同的是，我的实现允许共享指针清理分配的内存，而不是在应用程序退出并清理静态指针之前保留内存。
#pragma once
#include <memory>
template<typename T>
class Singleton
{
private:
static std::weak_ptr<T> _singleton;
public:
static std::shared_ptr<T> singleton()
{
std::shared_ptr<T> singleton = _singleton.lock();
if (!singleton)
{
singleton.reset(new T());
_singleton = singleton;
}
return singleton;
}
};
template<typename T>
std::weak_ptr<T> Singleton<T>::_singleton;
@洛基·阿斯塔里的回答很好。
然而，有时使用多个静态对象时，您需要能够保证在所有使用单例的静态对象不再需要它之前，单例不会被破坏。
在这种情况下，std:：shared_ptr可用于保持所有用户的单例有效，即使在程序结束时调用静态析构函数：
class Singleton
{
public:
Singleton(Singleton const&) = delete;
Singleton& operator=(Singleton const&) = delete;
static std::shared_ptr<Singleton> instance()
{
static std::shared_ptr<Singleton> s{new Singleton};
return s;
}
private:
Singleton() {}
};
