C++入门 -- 单例模式的原理与实现

设计模式 -- 把简单的代码复杂化 -- 方便后期维护

单例模式：

一般情况下，用户可以通过类构造很多个对象

#include <iostream>
#include <string>
using namespace std;

class Singleton {
   public:
    Singleton() { cout << "Singleton() construct" << endl; }
    ~Singleton() { cout << "~Singleton() destruct" << endl; }
};

int main(int argc, char const *argv[]) {
    Singleton s1;
    Singleton s2;
    return 0;
}

如果想要用户只能实例化一个对象，该怎么作？

将构造函数声明为private,因此外部只能通过类的成员方法来调用构造函数

在类中实现用户唯一创建对象的一个接口CreateObj，new一个对象并返回对象的指针

如果这个接口是普通成员函数，那么没有对象怎么调用创建对象的接口，即陷入先有鸡还是现有蛋的问题中

那么就可以将这个接口声明为static成员函数，与对象无关，与类域相关的全局函数

#include <iostream>
#include <string>
using namespace std;
//单例模式
class Singleton {
   public:
    ~Singleton() { cout << "~Singleton() destruct" << endl; }
    static Singleton* CreateObject() { return new Singleton(); }

   private:
    Singleton() { cout << "Singleton() construct" << endl; }
};

int main(int argc, char const* argv[]) {
    Singleton* p1 = Singleton::CreateObject();
    Singleton* p2 = Singleton::CreateObject();
    return 0;
}

接口是有了，但是调用两次接口还是生成了两个对象。

我们可以在创建接口里对生成的对象指针进行判断，若指针为空，则new一个对象，若不为空，则返回这个指针

因为要使这个指针不依赖与具体的对象，也要将它声明为static变量

#include <iostream>
#include <string>
using namespace std;

class Singleton {
   public:
    ~Singleton() { cout << "~Singleton() destruct" << endl; }
    static Singleton* CreateObject() {  //创建用户唯一的接口
        if (m_pObject == nullptr) {
            m_pObject = new Singleton();
        }
        return m_pObject;
    }

   private:
    Singleton() { cout << "Singleton() construct" << endl; }
    static Singleton* m_pObject;  
};

Singleton* Singleton::m_pObject = nullptr;

int main(int argc, char const* argv[]) {
    Singleton* pObj1 = Singleton::CreateObject();
    Singleton* pObj2 = Singleton::CreateObject();
    cout << pObj1 << endl;
    cout << pObj2 << endl;
    return 0;
}

out:

 只创建了一个对象。

但是还有内存泄漏的问题，如果释放资源，还得用户delete资源，并且这样做不是线程安全的

在创建接口中，我们使用了new,这就会带来麻烦，创建对象还要去释放。

所以我们在create函数中创建一个局部静态对象，并以指针的形式返回，在程序结束后，全局区的资源会自动释放

    static Singleton* CreateObject() {
        static Singleton obj;
        return &obj;  //返回对象的指针
    }

使用指针的话，会误导用户使用delete语法来释放对象，且编译还不会报错，故此处使用引用

如下：

#include <iostream>
#include <string>
using namespace std;

class Singleton {
   public:
    ~Singleton() { cout << "~Singleton() destruct" << endl; }
    // static Singleton* CreateObject() {
    //     if (m_pObject == nullptr) {
    //         m_pObject = new Singleton();
    //     }
    //     return m_pObject;
    // }
    static Singleton& CreateObject() {
        static Singleton obj;
        return obj;  //返回引用
    }

   private:
    Singleton() { cout << "Singleton() construct" << endl; }
    static Singleton* m_pObject;
};

Singleton* Singleton::m_pObject = nullptr;

int main(int argc, char const* argv[]) {
    Singleton& pObj1 = Singleton::CreateObject();
    Singleton& pObj2 = Singleton::CreateObject();
    cout << &pObj1 << endl;
    cout << &pObj2 << endl;
    return 0;
}

但是这样还是会有问题，如果用户：

27     Singleton& pObj1 = Singleton::CreateObject();
28     Singleton  pObj2 = Singleton::CreateObject();

28行就相当于   Singleton pObj2 =  obj;  类的拷贝构造，编译器会为类生成一个默认的构造函数，来支持类的拷贝。这样又突破单例模式的限制了

 所有我们不仅仅要限制singleton的普通构造函数，还要限制它的拷贝构造函数。禁用拷贝构造，禁用默认的运算符重载

#include <iostream>
#include <string>
using namespace std;

class Singleton {
   public:
    ~Singleton() { cout << "~Singleton() destruct" << endl; }
    // static Singleton* CreateObject() {
    //     if (m_pObject == nullptr) {
    //         m_pObject = new Singleton();
    //     }
    //     return m_pObject;
    // }
    static Singleton& CreateObject() {
        static Singleton obj;  // 会调用构造函数
        return obj;            //返回对象的引用
    }
    Singleton(Singleton& obj) = delete;  //禁用拷贝构造函数
    Singleton* operator = (Singleton& obj) = delete; //禁用默认的运算符重载

   private:
    Singleton() { cout << "Singleton() construct" << endl; }
    static Singleton* m_pObject;
};

Singleton* Singleton::m_pObject = nullptr;

int main(int argc, char const* argv[]) {
    Singleton& pObj1 = Singleton::CreateObject();
    Singleton pObj2 = Singleton::CreateObject();  // Singleton pObj2 = obj;
    cout << &pObj1 << endl;
    cout << &pObj2 << endl;
    return 0;
}

 推荐：

C++中的单例模式