单例模式实现要点：
- 构造函数私有化 - 为避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
- 类中创建一个本类对象 - 本类中自定义对象，让其他程序可以访问
- 提供方法获取到该对象 - 方便其他程序对自定义对象的访问
单例模式实现方式：
1.懒汉式(多线程不安全) - 需要时才进行实例化。
#include<iostream>
using namespace std;
#include <windows.h>
//核心的本质就是，只能实例化一个实体
class Singleton {
private:
Singleton() {}
Singleton(Singleton&) = delete; //禁止使用
Singleton& operator=(const Singleton&object) = delete; //禁止使用
public:
~Singleton() {}
//获取一个实例
static Singleton* getInstance() {
//如果指针为空，则重新创造一个实例
if (m_instance_ptr == nullptr) {
m_instance_ptr = new Singleton;
}
//否则，说明已经创建过了，直接返回
return m_instance_ptr;
}
void func()
{
cout << "成功实例化了！！！" << endl;
}
private:
static Singleton* m_instance_ptr;
};
Singleton* Singleton::m_instance_ptr = nullptr;//在外部对指针进行初始化
int main() {
static Singleton* instance = Singleton::getInstance();
instance->func();
system("pause");
return 0;
}
问题1：static Singleton* m_instance_ptr; 中的static有什么作用
在这个代码中，
static关键字用于声明m_instance_ptr成员变量为静态变量。静态变量是属于类而不是类的实例的变量，因此在整个程序运行期间只会有一个m_instance_ptr变量的实例。这使得在getInstance()方法中可以对该变量进行检查，确保只创建一个Singleton类的实例。
问题2： c++ static是不是就只有一份数据，每次操作都会直接作用在本体上
是的，C++中的静态数据成员只有一份数据，不会随着对象的创建而分配新的内存空间。每次操作都会直接作用在这份数据上，不会因为对象的创建而产生新的副本。因此，静态数据成员可以被所有对象共享，并且可以在不创建对象的情况下直接访问和修改。
2.懒汉式（多线程安全）-进行加锁
#include <iostream>
#include <memory> // shared_ptr
#include <mutex> // mutex
class Singleton {
public:
typedef std::shared_ptr<Singleton> Ptr;
~Singleton() {
std::cout << "析构函数！！！" << std::endl;
}
Singleton(Singleton&) = delete; //禁止使用
Singleton& operator=(const Singleton&) = delete; //禁止使用
static Ptr getInstance() {
if (m_instance_ptr == nullptr) {
std::lock_guard<std::mutex> auto_lock(m_mutex);
if (m_instance_ptr == nullptr) {
m_instance_ptr = std::shared_ptr<Singleton>(new Singleton);
}
}
return m_instance_ptr;
}
void use() const {
std::cout << "已经成功初始化了" << std::endl;
}
private:
Singleton() {}
static Ptr m_instance_ptr;
static std::mutex m_mutex;
};
Singleton::Ptr Singleton::m_instance_ptr = nullptr;
std::mutex Singleton::m_mutex;
int main() {
Singleton::Ptr instance = Singleton::getInstance();
instance->use();
system("pause");
return 0;
}问题1：shared_ptr<Singleton>有什么作用
使用
std::shared_ptr<Singleton>可以确保在程序中只有一个实例对象，并且可以方便地在需要时访问该实例对象。std::shared_ptr是智能指针的一种，它可以自动管理对象的生命周期，确保在不再需要时正确地释放对象，避免内存泄漏。在这个示例中，std::shared_ptr<Singleton>确保了只有一个Singleton对象实例，并且在程序结束时正确地释放该实例对象。
问题2： 上面的代码加锁了，难道不用解锁吗
在上面的代码示例中，确实在获取单例对象实例时使用了
std::lock_guard<std::mutex>来加锁，但是没有显式地解锁。这是因为std::lock_guard是一个RAII（资源获取即初始化）类，它在构造时会自动锁住互斥量，在析构时会自动释放锁，即在作用域结束时会自动解锁。因此，在上面的代码中，当
std::lock_guard<std::mutex>对象auto_lock超出作用域时，会自动调用析构函数，从而释放锁，不需要显式地调用解锁操作。这样可以确保在任何情况下都能正确释放锁，避免忘记解锁而导致的死锁问题。
问题3：静态变量都需要在类外进行初始化吗？
在C++中，静态成员变量必须在类外进行定义和初始化。这是因为静态成员变量是属于类的，而不是属于类的实例，因此需要在类外进行定义和初始化。
在上面的代码中，
singleton::ptr和singleton::m_mutex都是singleton类的静态成员变量，因此需要在类外进行初始化。静态成员变量的初始化必须在全局作用域进行，以确保在程序运行之前就完成了初始化。通过在全局作用域进行初始化，确保了静态成员变量在程序运行时已经被正确初始化，可以在类的静态成员函数或其他地方使用这些静态成员变量。
问题4： NULL和nullptr有什么区别
NULL和nullptr是C++中用于表示空指针的关键字，它们在一些方面有一些区别：
NULL是在C语言中定义的宏，通常被定义为0或者(void*)0。在C++中，NULL通常被定义为0。因此，NULL实际上是一个整数值的常量。
nullptr是C++11引入的关键字，用于表示空指针常量。nullptr是一个特殊的空指针值，不是整数类型，而是属于nullptr_t类型。因此，nullptr可以更好地表示空指针，避免了一些潜在的问题。在C++11及以后的标准中，推荐使用
nullptr来表示空指针，而不是NULL。因为nullptr具有更好的类型安全性，可以避免一些潜在的类型转换问题。综上所述，
nullptr是C++11引入的更安全和更明确的表示空指针的关键字，推荐在新的C++代码中使用nullptr来表示空指针。而NULL仍然可以在一些老的代码中使用，但最好在新代码中使用nullptr。
3.饿汉式-提前实例化
#include <iostream>
class Singleton {
public:
~Singleton() {
std::cout << "析构函数！！！" << std::endl;
}
Singleton(Singleton&) = delete; //禁止使用
Singleton& operator=(const Singleton&) = delete; //禁止使用
static Singleton* getInstance() {
return m_instance;
}
void use() const {
std::cout << "已经实例化对象了！！！" << std::endl;
}
private:
Singleton() {}
static Singleton* m_instance;
};
//直接在外部就只实例化一个对象，避免的多创建的风险
Singleton* Singleton::m_instance = new Singleton;
int main() {
Singleton* instance = Singleton::getInstance();
instance->use();
system("pause");
return 0;
}
