单例模式

一、要点

0.单例模式，顾名思义只能有一个实例对象
1.私有化构造函数：不能随便调用构造函数来实例化对象
2.删除拷贝构造函数、赋值运算符函数：确保唯一实例
3.利用静态成员变量，存储指向单例对象的指针：静态方法属于类，不属于具体的实例对象。
4.提供静态方法，在堆上获取单例对象

二、代码

耽误实例化、懒加载、懒汉式：实例在第一次利用时才会被创建

1.核心代码

1. static Singleton* getInstance() {
2.     if (instance == nullptr) {
3.         instance = new Singleton();  // 只有在第一次调用时创建实例
4.     }
5.     return instance;
6. }

复制代码

2.具体注释代码

1. #include <iostream>
2. using std::cout;
3. using std::endl;
5. //单例模式:要通过给的接口来创造唯一实例。
6. //因此，要将构造函数私有化，并且删除拷贝构造和赋值运算符函数
8. class Singleton
9. {
10. public:
11.     //静态方法,用于获取唯一的实例。静态方法属于类，而非实例对象
12.     //懒加载、懒汉式、延迟实例化
13.     static Singleton* getInstance()
14.     {
15.         if(pInstance == nullptr){
16.             pInstance = new Singleton();
17.         }
18.         return pInstance;
19.     }
21.     void display()
22.     {
23.         cout << "This is the Singleton instance." << "\n";
24.     }
25. private:
26.     //构造函数私有化，防止外部创建对象
27.     Singleton()
28.     {
29.         cout << "Singleton instance created.\n";
30.     }
32.     //禁用拷贝构造和赋值运算符函数
33.     Singleton(const Singleton & ) = delete;
34.     Singleton & operator=(const Singleton &) = delete;
36.     //静态成员变量，存储唯一的实例
37.     static Singleton* pInstance;
38. };
40. //类外初始化静态成员变量
41. Singleton* Singleton::pInstance = nullptr;
43. int main()
44. {
45.     //获取单例对象的唯一实例
46.     Singleton* s1 = Singleton::getInstance();
47.     s1->display();
49.     //再次获取单例对象的实例
50.     Singleton* s2 = Singleton::getInstance();
51.     s2->display();
53.     //验证两个指针是否指向同一个实例
54.     if(s1 == s2){
55.         cout << "Both pointer point to the same instance.\n";
56.     }
58.     return 0;
59. }

复制代码

另一版

1. #include <iostream>
2. using std::cout;
3. using std::endl;
5. //单例模式:要通过给的接口来创造唯一实例。
6. //因此，要将构造函数私有化，并且删除拷贝构造和赋值运算符函数
8. class Singleton
9. {
10. private:
11.     //构造函数私有化，防止外部创建对象
12.     Singleton()
13.     {
14.         cout << "Singleton instance created.\n";
15.     }
17.     //禁用拷贝构造和赋值运算符函数
18.     Singleton(const Singleton & ) = delete;
19.     Singleton & operator=(const Singleton &) = delete;
21.     //静态成员变量，存储唯一的实例
22.     static Singleton* instance;
23. public:
24.     //静态方法,用于获取唯一的实例
25.     static Singleton* getInstance()
26.     {
27.         if(instance == nullptr){
28.             instance = new Singleton(); //延迟实例化
29.         }
30.         return instance;
31.     }
33.     void display()
34.     {
35.         cout << "This is the Singleton instance." << "\n";
36.     }
37. };
39. //静态成员变量初始化为nullptr
40. Singleton* Singleton::instance = nullptr;
42. int main()
43. {
44.     //获取单例对象的唯一实例
45.     Singleton* s1 = Singleton::getInstance();
46.     s1->display();
48.     //再次获取单例对象的实例
49.     Singleton* s2 = Singleton::getInstance();
50.     s2->display();
52.     //验证两个指针是否指向同一个实例
53.     if(s1 == s2){
54.         cout << "Both pointer point to the same instance.\n";
55.     }
57.     return 0;
58. }

复制代码

3.无注释代码 (单线程时，存在线程安全问题)

1. #include <iostream>
2. using std::cout;
3. using std::endl;
5. class Singleton
6. {
7. public:
8.     static Singleton* getInstance()
9.     {
10.         if(pInstance == nullptr){
11.             pInstance = new Singleton();
12.         }
13.         return pInstance;
14.     }
16. private:
17.     Singleton(){};
18.     Singleton(const Singleton & rhs) = delete;
19.     Singleton & operator= (const Singleton & rhs) = delete;
20.     static Singleton* pInstance;
21. };
23. Singleton* Singleton::pInstance = nullptr;
25. int main()
26. {
27.     Singleton* s1 = Singleton::getInstance();
28.     Singleton* s2 = Singleton::getInstance();
29.     if(s1 == s2){
30.         cout << "s1 == s2,是单例的\n";
31.     }else{
32.         cout << "s1 != s2,不是单例的\n";
33.     }
35.     return 0;
36. }

复制代码

4.思量线程安全 (getInstance加锁)

1. #include <iostream>
2. #include <mutex>
3. using std::cout;
4. using std::mutex;
5. using std::lock_guard;
7. class Singleton
8. {
9. public:
10.     static Singleton* getInstance()
11.     {
12.         lock_guard<mutex> lock(mtx);
13.         if(pInstance == nullptr){
14.             pInstance = new Singleton();
15.         }
16.         return pInstance;
17.     }
19. private:
20.     Singleton(){};
21.     Singleton(const Singleton & rhs) = delete;
22.     Singleton & operator= (const Singleton & rhs) = delete;
23.     static Singleton* pInstance;
24.     static mutex mtx; //互斥锁，确保线程安全
25. };
27. Singleton* Singleton::pInstance = nullptr;
28. mutex Singleton::mtx;
30. int main()
31. {
32.     Singleton* s1 = Singleton::getInstance();
33.     Singleton* s2 = Singleton::getInstance();
34.     if(s1 == s2){
35.         cout << "s1 == s2,是单例的\n";
36.     }else{
37.         cout << "s1 != s2,不是单例的\n";
38.     }
40.     return 0;
41. }

复制代码

4.1 进一步减少加锁的开销，利用双重查抄锁

1. // 线程安全的 getInstance 方法，使用双重检查锁
2. static Singleton* getInstance()
3. {
4.     if(pInstance == nullptr) {  // 第一次检查，无锁
5.         std::lock_guard<std::mutex> lock(mtx);  // 加锁
6.         if(pInstance == nullptr) {  // 第二次检查，加锁后
7.             pInstance = new Singleton();
8.         }
9.     }
10.     return pInstance;
11. }

复制代码

5.开释单例资源以避免内存泄露(智能指针)

1. #include <iostream>
2. #include <mutex>
3. #include <memory>
5. using std::cout;
6. using std::mutex;
7. using std::lock_guard;
8. using std::unique_ptr;
10. class Singleton
11. {
12. public:
13.     static Singleton* getInstance()
14.     {
15.         lock_guard<mutex> lock(mtx);
16.         if(pInstance == nullptr){
17.             /* pInstance = new Singleton(); */
18.             pInstance = unique_ptr<Singleton>(new Singleton());
19.         }
20.         return pInstance.get();
21.     }
23. private:
24.     Singleton(){};
25.     Singleton(const Singleton & rhs) = delete;
26.     Singleton & operator= (const Singleton & rhs) = delete;
27.     /* static Singleton* pInstance; */
28.     static unique_ptr<Singleton> pInstance;
29.     static mutex mtx; //互斥锁，确保线程安全
30. };
32. /* Singleton* Singleton::pInstance = nullptr; */
33. unique_ptr<Singleton> Singleton::pInstance = nullptr;
34. mutex Singleton::mtx;
36. int main()
37. {
38.     Singleton* s1 = Singleton::getInstance();
39.     Singleton* s2 = Singleton::getInstance();
40.     if(s1 == s2){
41.         cout << "s1 == s2,是单例的\n";
42.     }else{
43.         cout << "s1 != s2,不是单例的\n";
44.     }
46.     return 0;
47. }

复制代码

6.饿汉式

饿汉式：在类加载时就举行实例化

1. #include <iostream>
2. using namespace std;
4. class Singleton{
5. public:
6.     // 提供全局访问点
7.     static Singleton& getInstance()
8.     {
9.         // 静态局部变量在程序启动时初始化
10.         static Singleton instance;
11.         return instance;
12.     }
14.     // 删除拷贝构造函数和赋值操作符，防止复制
15.     Singleton(const Singleton&) = delete;
16.     Singleton& operator=(const Singleton&) = delete;
18.     // 示例方法
19.     void display() const{
20.         cout << "Singleton::display() called on instance: " << this << endl;
21.     }
22. private:
23.     // 私有构造函数
24.     Singleton(){
25.         cout << "Singleton()" << endl;
26.     }
27.     // 私有析构函数
28.     ~Singleton(){
29.         cout << "~Singleton()" << endl;
30.     }
31. };
33. int main()
34. {
35.     // 通过getInstance获取单例对象的引用，并调用示例方法
36.     Singleton& s1 = Singleton::getInstance();
37.     s1.display();
39.     // 再次获取单例对象的引用，验证它们是同一个实例
40.     Singleton& s2 = Singleton::getInstance();
41.     s2.display();
43.     // 输出将展示s1和s2有相同的地址，说明它们是同一个实例
44.     return 0;
45. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。