c++11 实现单例模式

实现单例模式的经典方式是将构造函数私有化，然后提供一个静态方法来返回单例对象的指针或引用。C++11 中引入了线程安全的局部静态变量，可以通过这种方式实现单例模式的线程安全性。

下面是一个使用线程安全的局部静态变量实现的单例模式示例：

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

在上面的示例中，getInstance() 方法返回一个 Singleton 类型的引用，该方法内部定义了一个静态局部变量 instance，该变量在首次调用 getInstance() 时进行初始化。由于静态局部变量的初始化是线程安全的，因此 Singleton 类的实例化是线程安全的。同时，由于 Singleton 类的构造函数和拷贝构造函数被定义为私有，禁止外部代码创建 Singleton 类的实例和拷贝实例，从而实现了单例模式。

相关问题

UE C++ 如何实现单例模式

在Unreal Engine (UE) 中使用C++ 实现单例模式，通常有两种常见的方式：

### 1. 静态工厂函数

// Singleton.h
class MyClass
{
public:
    static MyClass& GetInstance();
    // 其他成员函数...
private:
    MyClass() {} // 构造函数私有，防止直接实例化
    ~MyClass() = default; // 析构函数默认也是私有的，防止删除
};

// Singleton.cpp
MyClass* MyClass::GetInstance()
{
    static MyClass instance;
    return &instance;
}

这里 `GetInstance` 函数返回的是单例实例的引用，保证了在整个程序运行期间只有一个实例。

### 2. 使用无模板的Smart指针

// Singleton.h
#include <ue_module_headers.h>
UCLASS()
class MYPROJECT_API AMySingleton : public UObject
{
    GENERATED_BODY()

public:
    static AMySingleton* Get();
    // 其他成员函数...

private:
    friend class FDefaultSubobjectRegistration;

    static TSharedPtr<AMySingleton> Singleton;
    explicit AMySingleton() {}
    virtual ~AMySingleton() {}
};

在`Singleton.cpp` 中初始化单例：

TSharedPtr<AMySingleton> AMySingleton::Singleton = nullptr;

AMySingleton* AMySingleton::Get()
{
    if (!Singleton)
    {
        Singleton = MakeShareable(new AMySingleton);
    }
    return Singleton.Get();
}

这种方式利用了UObject的智能指针系统，保证单例的生命周期与Unreal Engine一致。

**相关问题--:**
1. UE4中的静态工厂函数如何确保线程安全？
2. 使用Smart指针实现单例有何优点？
3. 如何在Unreal项目的构造/析构函数中注册或注销单例？

只有c++11支持单例模式

在C++中，单例模式是一种设计模式，它保证一个类只有一个实例，并提供全局访问点。从C++11开始，标准库引入了一些改进，使得单例模式的实现更加容易并且避免了传统单例模式可能导致的一些问题，如无初始化的静态成员引发的问题、多线程安全等。

C++11引入了`std::make_unique`和`std::shared_ptr`等智能指针，可以更优雅地创建并管理单例。例如，使用`std::singleton<T>`模板可以帮助我们实现线程安全的单例：

template <typename T>
class Singleton {
private:
    static std::once_flag flag;
    static std::unique_ptr<T> instance;

public:
    static T& getInstance() {
        std::call_once(flag, [] { instance = std::make_unique<T>(); });
        return *instance;
    }
};

template <typename T>
std::once_flag Singleton<T>::flag;
template <typename T>
std::unique_ptr<T> Singleton<T>::instance(nullptr);

// 使用示例
Singleton<MyClass>& myInstance = Singleton<MyClass>::getInstance();

这样的实现既保证了每个线程只会初始化一次实例，又实现了自动内存管理，无需手动删除单例。