C++实现单例模式及遇到的问题_下述c++单例类有没有问题-优快云博客

通常而言，单例模式分为三种实现方式：

懒汉式：系统定义实例。
饿汉式：直接给用户定义一个实例，以后都是直接调用这个。
双重检验：通常用于多线程时线程安全的代码。

首先，展示一个错误的代码示范：（C++11）

class Singleton{
    public:
    static Singleton getInstance(){
        if(single) return single;
        else 
            single = new Singleton();
        
        cout<<"ADDR: "<<&single<<endl; // 对象，用取地址符输出地址，用于比较是否为同一个实例
        return single;
    }
    
    private:
    static Singleton single;
    Singleton()=default;
    ~Singleton()=default;
}

对于初学者来说，咋一看可能没觉得有问题，其实有两个严重问题，如下：

问题1：

 if(single) return single

编译器会告诉你:

could not convert ‘Singleton::single’ from ‘Singleton’ to ‘bool’

一般人会认为，对象没创建时肯定是空，也就是bool类型的false，好像可以用if直接判断。显然编译器已经告诉了我们答案：绝对不可以！

准确来说，Singleton::single是一个未识别的类型，因为是你自己定义的，除非你自己通过重载运算符之类的定义了隐式转换，否则，编译器无法为你进行隐式转换成bool类型。

问题2：

            single = new Singleton();

new产生一个新的对象，返回的不是新的对象！而是指向这个新对像的指针!

可以看一下new的底层调用形式：

void * operator new(size_t size)

很明显，返回的是指针。所以，用来接收收新对象时须定义一个指针。

补充：

这里使用static修饰实例对象是因为，单例，即这个类只能存在这一个实例，显然，static符合。
把构造函数和析构函数私有化，就是为了防止用户直接调用构造函数，破坏单例。

下面，开始贴上正确代码：

1. 懒汉式

#include <iostream>

using namespace std;

class Singleton{
    public:
    static Singleton* getInstance(){
        if(single== nullptr)  
            single = new Singleton();
        
        cout<<"ADDR: "<<single<<endl;  // &single替换成single，因为single本身存的就是地址了
        return single;
    }
    
    private:
    static Singleton *single;
    Singleton()=default;
    ~Singleton()=default;
};
 Singleton* Singleton::single = nullptr;
int main()
{
   Singleton* s;
   s->getInstance();
   Singleton* s2;
   s2->getInstance();
   Singleton* s3;
   s3->getInstance();
   return 0;
}

输出：

$g++ -std=c++11 -o main *.cpp
$main
ADDR: 0x601178
ADDR: 0x601178
ADDR: 0x601178

2. 饿汉式

#include <iostream>

using namespace std;

class Singleton{
    public:
    static Singleton* getInstance(){
        if(single== nullptr)  
            single = new Singleton();
        
        cout<<"ADDR: "<<single<<endl;
        return single;
    }
    void destroy(){
        cout<<"Invoke deconstructor."<<endl;
        delete single; //销毁对象，但指针仍指着那块地址。
        single = nullptr; //重置指针
    }
    
    private:
    static Singleton *single;
    Singleton()=default;
    ~Singleton()=default;
};
 Singleton* Singleton::single = new Singleton() ; // 直接实例化
int main()
{
   Singleton* s=Singleton::getInstance();
   s->destroy();

   Singleton* s2=Singleton::getInstance();
   s2->destroy();

   Singleton* s3=Singleton::getInstance();
   
   return 0;
}

对应的输出：

$g++ -std=c++11 -o main *.cpp
$main
ADDR: 0x991c20
Invoke deconstructor.
ADDR: 0x991c20
Invoke deconstructor.
ADDR: 0x991c20

3. 双重校验--用于多线程甚至多进程环境。

#include <iostream>
#include<pthread.h>
using namespace std;
class Singleton{
    public:
    static Singleton* getInstance(){
        if(single== nullptr)  {
            pthread_mutex_lock(&mutex_);
            if(single== nullptr)
                 single = new Singleton();
            pthread_mutex_unlock(&mutex_);
        }
        cout<<"ADDR: "<<single<<endl;
        return single;
    }
    void destroy(){
        cout<<"Invoke deconstructor."<<endl;
        delete single; //销毁对象，但指针仍指着那块地址。
        single = nullptr; //重置指针
    }
    
    private:
    static Singleton *single;
    static pthread_mutex_t mutex_;
    Singleton()=default;
    ~Singleton()=default;
};
 Singleton* Singleton::single = nullptr ; // 直接实例化
 pthread_mutex_t Singleton::mutex_;
 void gg(){
     Singleton::getInstance();
 }
int main()
{
   
    pthread_t p1,p2;
    pthread_create (&p1,NULL,gg,NULL);
    pthread_create (&p2,NULL,gg,NULL);
   
   return 0;
}

作为进一步补充，可以参考一下网友的C++完美单例模式。