C++计划模式--单例模式

单例模式的学习笔记
单例模式是为了：在整个系统生命周期内，保证一个类只能产生一个实例，确保该类的唯一性
参见链接1，链接2

1. #include <iostream>
2. #include <mutex>
4. using namespace std;
7. /*懒汉模式：只有在用到了才实例化对象并返回（调用了对外的接口才会实例对象）*/
8. /*构造函数私有化，只对外提供一个接口*/
10. /*线程不安全*/
11. class singleClass {
12. public:
14.         static singleClass* getInstance() // 对外接口，静态成员函数调用静态成员变量
15.         {
16.                 if (m_instance == nullptr)  // 在多线程的环境下，在判空的时候可能存在多个线程同时进入if中，此时可能会实例化多个对象
17.                 {
18.                         m_instance = new singleClass();
19.                 }
20.                 return m_instance;
21.         }
23. private:
24.         static singleClass* m_instance;  // 静态成员变量，类内声明，类外初始化
25.         singleClass() {}    // 构造函数属性设置为私有
27.         singleClass (const singleClass & sc) {}  // 拷贝构造函数也设置为私有
28. };
30. singleClass* singleClass::m_instance = nullptr;   // 初始化静态变量
32. /*线程安全*/
33. class threadSingleClass
34. {
35. public:
36.         static threadSingleClass* getInstance()
37.         {
38.                 if (m_instance == nullptr)   // 先判断是否为空，为空就进入；不为空，说明已经存在实例，返回
39.                 {
40.                         //m_mutex.lock();   // 这里如果使用unique_lock就不需要在下面解锁
41.                         unique_lock<mutex> lock(m_mutex);
42.                         if (m_instance == nullptr)   // 再次判断，确保不会因为加锁期间多个线程同时进入
43.                         {
44.                                 m_instance = new threadSingleClass();
46.                         }
47.                         //m_mutex.unlock();
48.                 }
49.                 return m_instance;
50.         }
52. private:
53.         static threadSingleClass* m_instance;
54.         static mutex m_mutex;
56.         threadSingleClass() {};
57.         threadSingleClass(const threadSingleClass& sc) {}
58. };
60. threadSingleClass* threadSingleClass::m_instance = nullptr;
61. mutex threadSingleClass::m_mutex;
64. /*饿汉模式：不管调不调用对外接口，都已经实例化对象了。本身就是线程安全的*/
65. /*类在加载的时候就实力化对象，所以要提前占用系统资源*/
66. class hungrySingleClass
67. {
68. public:
69.         static hungrySingleClass* getInstance()
70.         {
71.                 return m_instance;
72.         }
74. private:
75.         static hungrySingleClass* m_instance;
76.         hungrySingleClass() {}
77.         hungrySingleClass(const hungrySingleClass* sc) {}  // 拷贝构造私有
78. };
80. hungrySingleClass* hungrySingleClass::m_instance = new hungrySingleClass();
81. // 类外定义，main开始执行前，该对象就存在了
84. int main()
85. {
86.         singleClass* singlep1 = singleClass::getInstance();
87.         singleClass* singlep2 = singleClass::getInstance();
89.         cout << singlep1 << endl;
90.         cout << singlep2 << endl;
92.         threadSingleClass* thsinglep1 = threadSingleClass::getInstance();
93.         threadSingleClass* thsinglep2 = threadSingleClass::getInstance();
95.         cout << thsinglep1 << endl;
96.         cout << thsinglep2 << endl;
98.         hungrySingleClass* hgsinglep1 = hungrySingleClass::getInstance();
99.         hungrySingleClass* hgsinglep2 = hungrySingleClass::getInstance();
101.         cout << hgsinglep1 << endl;
102.         cout << hgsinglep2 << endl;
105.         system("pause");
106.         return 0;
107. }

复制代码

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