单例模式

c++的设计模式：

1 单例模式（Singleton Pattern)

单例模式：是最简单的设计模式之一。但是确实很有用的设计模式，因为很多时候，在同一个系统中，我们希望某个类在创建对象的时候，只能创建一个，比如日志对象，数据库连接池对象，读写文件的对象等。

往往这些对象都功能比较简单，重复的做同一个功能。

 分析实现

1 该对象创建在栈空间中---------------> 不行，因为当结束之后，会被自动进行释放，所以不可取。

2 在堆中进行创建，由程序员自己手动进行创建。（可行） 可以查看下面的扩展更好理解一点

其实理解了如何只生成堆对象之后，这个就是水到渠成的

具体的实现，(使用裸露的单例模式其实是不合理的，因为在释放的时候，基本上一定会报错,要写一个自己释放的函数)

class RealSingleton{
public:
    static RealSingleton* get_instance(int data);       // 这个的参数就是构造函数的参数，这个现在就是构造函数
    int get_data() const;
    void set_data(int data);
    ~RealSingleton();
private:
    RealSingleton(int data);                    // 所有的参数的传递都是不影响的
private:
    int _data;
    static RealSingleton *pinstance;
};
​
// 执行过程
void test4()
{
    RealSingleton *p1 = RealSingleton::get_instance(123456);
    cout << "p1's address : " << (void *)p1 << endl;
    cout << "p1->data : " << p1->get_data() << endl;
​
    RealSingleton *p2 = RealSingleton::get_instance(987654);
    cout << "p2's address : " << (void *)p2 << endl;
    cout << "p2->data : " << p2->get_data() << endl;
​
    delete p1; 
    delete p2;            // 当delete两次的时候是会出问题的，所以不行
}

结果：
RealSingleton(int)
p1's address : 0x557cabaf52e0
p1->data : 123456
p2's address : 0x557cabaf52e0
p2->data : 123456
[1]    1937361 segmentation fault (core dumped)  ./a.out          // 已经产生了coredump,所以不能

class RealSingleton{
public:
    static RealSingleton* get_instance(int data);       // 这个的参数就是构造函数的参数，这个现在就是构造函数
    int get_data() const;
    void set_data(int data);
    static void release_instance();                    // 手动进行释放即可
private:
    RealSingleton(int data);                           // 所有的参数的传递都是不影响的
    ~RealSingleton();
private:
    int _data;
    static RealSingleton *pinstance;
};

扩展：

1 创建一个类，只能在栈上创建对象

分析：其实这个和好实现的，只要将operator new 或者是 operator delete删除掉即可/或者是设置为private也可以

void *operator new(std::size_t size) = delete;
void operator delete(void *p) = delete;
​
例子：
class SingletonStack{                                                                                                                                 
public:
    SingletonStack(int data = 1000);
    ~SingletonStack();
    void setData(int data);
    int getData();
    void *operator new(std::size_t size) = delete;
private:
    int _data;
};
​

2 创建一个类，只能在堆上创建对象

分析：如果只生成堆上的对象，那么可以将构造函数搞成私有的，这样就可以实现不能在栈上创建对象了

但是这个时候，堆上也是不能进行创建的，因为堆上创建对象的时候，也是需要构造函数的，所以要重新写一个函数来实现获取这个对象

class SingletonHeap{                                                                                                                                                                        
public:
    void setData(int data);
    int getData()const;
    ~SingletonHeap();
    static SingletonHeap *get_heap_singleton(int data);        // 此时这个函数就相当于是构造函数了，构造函数需要的一                                                                // 切参数都是通过该函数来进行传递的
private:
    SingletonHeap(int data = 10000);
private:
    int _data;
};

扩展2 

后面可以写一下，RAII技术，结合智能指针来进行一下实现，其实真的这些知识点都是一串一串的