C++如何实现单例模式？

这是在看侯捷C++视频的时候，他提出的一个问题，称之为单例模式（singleton），有两种实现方式（懒汉与饿汉），还有多线程，使用场景（工厂模式）等等一些相关的东西，更多了解可以去百度一下。

什么是单例？

程序在设计上必须保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

主要难点：

• 限制实例数量
• 线程安全（目前只考虑到这一步即可）
• singleton 相互引用
• dead-reference

饿汉模式：指全局的单例实例在类加载时就被构建

class Singleton
{
public:
    static Singleton &getObject()//给外界的唯一接口
    {
        return instance;
    }
    void set(int t)
    {
        data = t;
    }
    void print()
    {
        cout << "data == " << data << endl;
    }
    //其他成员函数
private:
    Singleton(){};
    ~Singleton(){};

    Singleton(const Singleton &rhs);            //拷贝构造函数
    Singleton &operator=(const Singleton &rhs); //拷贝赋值运算符

    Singleton(const Singleton &&rhs);            //移动构造函数
    Singleton &operator=(const Singleton &&rhs); //移动赋值运算符

    static Singleton instance;
    int data;
};

Singleton Singleton::instance; //注意需要在类外定义

int main(void)
{
    Singleton::getObject().set(666);
    Singleton::getObject().print();

    return 0;
}

优点：

• 实现简单，多线程安全（多个线程对该实例的访问是在创建之后。但是我有疑问的是如果是多个线程写该单例的话，该如何处理这个问题呐？？？）
• 避免频繁加锁的性能消耗

缺点：

• 如果存在多个单例对象且这几个单例对象相互依赖，可能会出现程序崩溃的危险。
• 在程序开始之初，就创建单例。如果单例的创建开销较大，但是后面又没有使用，对于程序的资源的使用就是有问题的。
• 更加细致的比如说，编译时的相互依赖问题。比如：有另一个实例要依赖于该单例了 ，但是该单例还没有编译完成。这就会出现问题。

为什么能够实现的基础原理保证：

C++11 保证静态局部变量的初始化过程是线程安全的。

这里的线程安全指的是：一个线程在初始化 m 的时候，其他线程执行到 m 的初始化这一行的时候，就会挂起。

懒汉模式：指全局的单例实例在第一次被使用时构建。

class Singleton
{
public:
    static Singleton &getObject() //给外界的唯一接口
    {
        static Singleton instance; //staic 离开函数仍然存在
        return instance;
    }
    void set(int t)
    {
        data = t;
    }
    void print()
    {
        cout << "data == " << data << endl;
    }
    //其他成员函数
private:
    Singleton(){};
    ~Singleton(){};

    Singleton(const Singleton &rhs);            //拷贝构造函数
    Singleton &operator=(const Singleton &rhs); //拷贝赋值运算符

    Singleton(const Singleton &&rhs);            //移动构造函数
    Singleton &operator=(const Singleton &&rhs); //移动赋值运算符

    int data;
};

int main(void)
{
    Singleton::getObject().set(445555454);
    Singleton::getObject().print();

    return 0;
}

当然了，使用 new 实现也是完全可以的。但是我觉得不是很建议。

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class A{
public:
    static A* getObject();
    void set(int t){
        temp = t ;
    }
    void print(){
        cout << "temp == "<< temp << endl ;
    }
    //其他成员函数
private:
    A() = default ;
    A(const A& rhs) ;
	~A(){   //析构函数即使在private中还是会自动执行，不用再写public函数 delete
        delete p_A ;
    }
    A& operator=(const A&); //把复制构造函数和=操作符也设为私有,防止被复制

    static A *p_A ;
    int temp ;
};
//注意初始化！！！
A* A::p_A = new A();
A* A::getObject(){
	return p_A;
}

int main(void){
    A* A1 = A::getObject();
    A* A2 = A::getObject();

	if (A1 == A2)
		fprintf(stderr,"A1 = A2\n");

    A1->set(888);
    A1->print();

	return 0;
}

运行结果：