单例模式

---恢复内容开始---

　　单例模式实现方式：将构造函数、拷贝构造函数、赋值构造函数声明为私有的。然后因为不能够创建对象，所以我们必须提供一个接口用于创建一个对象。必须将其声明为static静态成员函数，是指属于类而不属于对象，即整个类只有一份。静态成员函数只能访问静态数据成员，所以数据成员也要声明为静态的。

　　

#include<iostream>
using namespace std;
class Singleton
{
public:
    static Singleton* Getinstance()
    {
        //只能构造一个
        if (p == NULL)
            p = new Singleton();//成员函数可以调用私有成员函数
        return p;
    }
    ~Singleton() { cout << "~Singleton" << endl; }//并未调用对象析构函数
private:
    Singleton() { cout << "Singleton" << endl; };
    Singleton(const Singleton& other) {};
    Singleton& operator=(const Singleton& other) {};
    static Singleton* p;
};
Singleton* Singleton::p = NULL;
int main()
{
    Singleton* s1 = Singleton::Getinstance();//没有对象，只能通过类来调用静态方法
    Singleton* s2 = Singleton::Getinstance();
    return 0;
}

　　上述单例模式的实现存在两个问题，一是它并未调用析构函数，存在内存泄漏；而是它并不是线程安全的。首先解决内存泄漏问题。引入auto_ptr智能指针即可解决。

#include<iostream>
#include<memory>
using namespace std;
class Singleton
{
public:
    static Singleton* Getinstance()
    {
        //p.get()返回原生指针。
        if (!p.get())
            p = auto_ptr<Singleton>(new Singleton());//new Singleton，所有权转移
        return p.get();
    }
    ~Singleton() { cout << "~Singleton" << endl; }//并未调用析构函数
private:
    Singleton() { cout << "Singleton" << endl; };
    Singleton(const Singleton& other) {};
    Singleton& operator=(const Singleton& other) {};
    //static Singleton* p;
    //将裸指针用智能指针来管理
    static auto_ptr<Singleton> p;//析构函数会被调用
};
auto_ptr<Singleton> Singleton::p;//对象结束，静态对象也会被销毁。从而调用析构函数。
int main()
{
    Singleton* s1 = Singleton::Getinstance();
    Singleton* s2 = Singleton::Getinstance();
    return 0;
}

　　

　　也可以用以下的方法解决这个问题：

#include<iostream>
 #include<memory>
 using namespace std;
 class Singleton
 {
 public:
     static Singleton&  Getinstance()
     {
           static  Singleton instance;//局部静态对象是在运行期初始化。下一次再进入还是先前的对象。
           return instance;//返回了引用
    }
     ~Singleton() { cout << "~Singleton" << endl; }//会调用析构函数
 private:
     Singleton() { pthread_mutex_init(&mutex) };
     Singleton(const Singleton& other) {};
     Singleton& operator=(const Singleton& other) {};
 };
 int main()
 {
     Singleton&  s1 = Singleton::Getinstance();
    Singleton&  s2 = Singleton::Getinstance();
     return 0;
 }

　　第二个问题，要解决线程安全问题，可以引入互斥量。在创建单例对象的时候进行加锁。

 #include<iostream>
 #include<memory>
 #include<pthread.h>
 using namespace std;
 class Singleton
 {
 public:
     static Singleton* Getinstance()
     {
        pthread_mutex_lock(&mutex);
         if (!p.get())
             p =auto_ptr<Singleton>(new Singleton());
        pthread_mutex_unlock(&mutex);
         return p.get();
    }
     ~Singleton() { cout << "~Singleton" << endl; }//并未调用析构函数
 private:
     Singleton() { pthread_mutex_init(&mutex) };
     Singleton(const Singleton& other) {};
     Singleton& operator=(const Singleton& other) {};
     static auto_ptr<Singleton> p;
     static pthread_mutex_t mutex;
 };
 auto_ptr<Singleton> Singleton::p;
 pthread_mutex_t Singleton::mutex;
 int main()
 {
     Singleton* s1 = Singleton::Getinstance();
    Singleton* s2 = Singleton::Getinstance();
     return 0;
 }

---恢复内容结束---