C++实现单例模式

昨天面试的时候，面试官让我用C++或Java实现一个单例模式。

因为设计模式是在12年的时候学习过这门课，而且当时觉得这门课很有意思，所以就把课本读了几遍，所以印象比较深刻，但是因为实际编程中很少注意使用，所以没能编码实现。

这是之前用C#写的一个单例模式的文章：http://www.cnblogs.com/CheeseZH/archive/2012/05/14/2500546.html

什么是单例模式

单件模式（SingletonPattern）：确保一个类只有一个实例，并提供一个全局访问点。和全局变量一样方便，又没有全局变量的缺点，即不需要从一开始就创建对象，而是在需要时才创建它。

那么要如何保证一个类只能被实例化一次呢？一般情况下，如果存在一个类，我们都是可以多次地实例化它的。那么如果这样呢：

 public MyClass{
     private MyClass(){
     }
 }

咦？构造函数私有？含有私有的构造器的类应该是不能被其他类实例化的，因为只有MyClass内部的代码才能调用这个私有的构造函数。虽然只有MyClass类的实例才能调用MyClass构造器，但在这之前，必须有一个MyClass实例。然而这个类又不能被实例化，这样就产生了矛盾！

看下面这段代码：

 public MyClass{
     public static MyClass getInstance(){
     }
 }

上面的代码表示MyClass有一个静态方法，我们可以这样调用这个方法：MyClass.getInstance(); 因为getInstance()是一个静态方法，换句话说，是一个“类”方法。引用一个静态方法，你需要使用类名，而不是对象名。

那么把上面两段代码合在一起，是否就可以使MyClass只产生一个实例了呢？

看下面的代码：

 public class MyClass{
        //利用一个静态变量来记录MyClass类的唯一实例
        private static MyClass uniqueInstance;
        //私有构造函数，只有自MyClass类内才可以调用
        private MyClass() {}
        //用getInstance静态方法实例化对象，并返回
        public static MyClass getInstance(){
                 if(uniqueInstance == NULL)
                 {
                       uniqueInstance = new MyClass();
                 }
                 return uniqueInstance;
        }
        //当然，单件类也是一个正常的类，具有其他的变量和方法
        //...
 }

这就是一个经典的单件模式的实现！之所以实例唯一，是因为单件类没有公开的构造器，其他类不能自行将其实例化得到一个实例，而必须通过它的静态方法getInstance()去创建一个实例。

C++完整实现

Singleton.h

 #pragma once
 
 class Singleton{
 private:
     Singleton();
     ~Singleton();
     static Singleton* uniqueInstance;
 
 public:
     static Singleton* getInstance();
     // other methods...
 };

Singleton.cpp

 #include"Singleton.h"
 #include<iostream>
 using namespace std;
 
 Singleton::Singleton(){
 
 }
 
 Singleton::~Singleton(){
     if(uniqueInstance == NULL){
         return;
     }
     delete uniqueInstance;
     uniqueInstance = ;
 }
 
 Singleton* Singleton::getInstance(){
     if(uniqueInstance == NULL){
         uniqueInstance = new Singleton;
     }
     return uniqueInstance;
 }

main.cpp

 #include<iostream>
 #include"Singleton.h"
 using namespace std;
 
 Singleton* Singleton::uniqueInstance = NULL;
 
 int main(){
     Singleton* singleton1 = Singleton::getInstance();
     Singleton* singleton2 = Singleton::getInstance();
     if(singleton1 == singleton2){
         cout<<"Got same singleton!!"<<endl;
     }
     else{
         cout<<"Oh,no!got a different singleton!!"<<endl;
     }
     return ;
 }

一个完整的单例模式代码：

 #include<iostream>
 using namespace std;
 class CSingleton
 {
 private:
     CSingleton() {
     }
     ~CSingleton() {
         if (m_pInstance == NULL) {
             return;
         }
         delete m_pInstance;
         m_pInstance = NULL;
     }
     static CSingleton *m_pInstance;
 public:
     static CSingleton * GetInstance() {
         if(m_pInstance == NULL)
             m_pInstance = new CSingleton();
         return m_pInstance;
     }
 };
 CSingleton* CSingleton::m_pInstance = NULL;//类的静态成员变量需要在类外边初始化
 
 int main() {
 
     CSingleton* single1 = CSingleton::GetInstance();
     CSingleton* single2 = CSingleton::GetInstance();
 
     if (single1 == single2) {
         cout<<"Same"<<endl;
     }
     return ;
 }