单例饿汉式和饱汉区别c++

在C++中，单例模式是一种常用的软件设计模式，用于确保一个类只有一个实例，并提供全局访问点。有两种常见的实现单例模式的方式：饿汉式和饱汉式。

**饿汉式（Singleton with Lazy Initialization）：**
饿汉式是在类加载的时候就完成了初始化。这意味着在程序启动时，无论是否需要这个单例，单例对象都会被创建并立即初始化。这种方式的代码看起来简洁，不需要外部同步，但可能会导致一些资源过早占用，尤其是在内存有限或资源昂贵的情况下。

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

private:
    Singleton() {} // 构造函数为私有，防止实例化
    ~Singleton() {} // 虚拟析构函数，确保仅有一个实例
};

相关问题

饿汉式单例模式C++

饿汉式单例模式是一种常见的设计模式，它在程序启动时就实例化了单例对象，因此一加载程序就完成了初始化。这种方式的名字来源于它“先吃”（即预先加载）了单例，避免了懒汉式（延迟加载）可能带来的线程安全问题。

在C++中，饿汉式单例模式的实现通常如下：

// 使用静态成员变量和构造函数
class Singleton {
public:
    // 静态成员函数返回单例实例
    static Singleton& getInstance() {
        static Singleton instance; // 饿汉式：一开始就创建实例
        return instance;
    }

private:
    // 构造函数为私有，防止外部直接创建对象
    Singleton() {} 

    // 没有复制构造函数和赋值操作符，防止拷贝
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

饿汉式单例模式的优点是：
1. 实例化在编译期间完成，不需要依赖运行时环境，性能较好。
2. 线程安全，因为对象是在编译时创建的，没有线程同步的需求。

然而，饿汉式单例模式的缺点也很明显：
1. 所占内存固定，如果应用不需要该单例，在内存紧张的情况下可能浪费空间。
2. 如果程序中有多个模块需要这个单例，全局唯一的特性可能会导致模块间的耦合度增加。

用C++写出懒汉式单例模式和饿汉式单例模式的例子

以下是C++中懒汉式单例模式和饿汉式单例模式的例子：

1. 饿汉式单例模式

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数
public:
    static Singleton* getInstance() {
        return instance;
    }
};
Singleton* Singleton::instance = new Singleton(); // 在类外初始化静态成员变量

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    if (s1 == s2) {
        cout << "s1和s2是同一个实例" << endl;
    }
    return 0;
}

2. 懒汉式单例模式

2.1 简易版

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr; // 在类外初始化静态成员变量

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();    if (s1 == s2) {
        cout << "s1和s2是同一个实例" << endl;
    }
    return 0;
}

2.2 私有嵌套类-回收专用

class Singleton {
private:
    Singleton() {} // 私有构造函数
    ~Singleton() {} // 私有析构函数
    static Singleton* instance;
    class GarbageCollector { // 私有嵌套类
    public:
        ~GarbageCollector() {
            if (Singleton::instance != nullptr) {
                delete Singleton::instance;
                Singleton::instance = nullptr;            }
        }
    };
    static GarbageCollector gc; // 静态成员变量，程序结束时自动调用析构函数
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr; // 在类外初始化静态成员变量
Singleton::GarbageCollector Singleton::gc; // 在类外初始化静态成员变量

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    if (s1 == s2) {
        cout << "s1和s2是同一个实例" << endl;
    }
    return 0;
}