单例模式

单例实现方式一：懒汉模式

// 单例：懒汉模式，即在使用的时候才会创建实例对象。
// 懒汉模式存在线程安全的问题，当对象没有被创建的时候，多个线程同时访问，则会出现多个线程创建实例对象的问题，需要加锁
#include<mutex>
#include<iostream>
#include<cstdlib>
using namespace std;

mutex my_mutex;

class Test
{
public:
    ~Test();
    // 获取实例对象
    static Test* getInstance();
private:
    Test();
    Test(const Test& t);
    // 单一的实例对象,
    static Test* t; // 指针，没有初始化
};
// 类外初始化
Test* Test::t = NULL;

Test::Test()
{
}

Test::Test(const Test& t)
{
}

Test::~Test()
{
}

Test* Test::getInstance()
{
    // 多线程同时访问的时候， 就会发生多个线程创建实例对象的线程安全问题
    // 使用互斥锁
    if (t == NULL)
    {
        my_mutex.lock();
        if (t == NULL)
        {
            // 创建
            t = new Test;
        }
        my_mutex.unlock();
    }
    return t;
}

int main()
{
    Test *t1 = Test::getInstance();
    Test* t2 = Test::getInstance();
    cout << t1 << endl;
    cout << t2 << endl;
    system("pause");
    return EXIT_SUCCESS;
}

单例实现方式二：饿汉模式，实例对象被使用之前就已经被创建，不存在线程安全问题。

饿汉模式实现一：

// 饿汉模式一：实例对象在使用之前就已经被创建
#include<cstdlib>
#include<iostream>
using namespace std;
class MyTest2
{
public:
    ~MyTest2();
    static MyTest2* getInstance();
private:
    MyTest2();
    MyTest2(const MyTest2& t);
    static MyTest2 m_t;
};
MyTest2 MyTest2::m_t;

MyTest2::MyTest2()
{
}

MyTest2::MyTest2(const MyTest2& t)
{
}

MyTest2::~MyTest2()
{
}
MyTest2* MyTest2::getInstance()
{
    return &m_t;
}

int main()
{
    MyTest2 *t1 = MyTest2::getInstance();
    cout << t1 << endl;
    MyTest2* t2 = MyTest2::getInstance();
    cout << t2 << endl;
    system("pause");
    return EXIT_SUCCESS;
}

饿汉模式实现二：

// 饿汉模式：实例对象在使用之前就已经被创建
#include<cstdlib>
#include<iostream>
using namespace std;
class MyTest3
{
public:
    ~MyTest3();
    static MyTest3* getInstance();
private:
    MyTest3();
    MyTest3(const MyTest3& t);
    static MyTest3 *m_tt;
};
MyTest3* MyTest3::m_tt = new MyTest3;

MyTest3::MyTest3()
{
}

MyTest3::MyTest3(const MyTest3& t)
{
}

MyTest3::~MyTest3()
{
}
MyTest3* MyTest3::getInstance()
{
    return m_tt;
}

int main()
{
    MyTest3* t1 = MyTest3::getInstance();
    cout << t1 << endl;
    MyTest3* t2 = MyTest3::getInstance();
    cout << t2 << endl;
    system("pause");
    return EXIT_SUCCESS;
}

单例实现方式三：使用静态局部变量方式实现，该方式只有支持C++11标准才行。

// C++11新特性，使用静态局部变量实现
#include<cstdlib>
#include<iostream>
using namespace std;
class MyTest1
{
public:
    ~MyTest1();
    static MyTest1* getInstance();
private:
    MyTest1();
    MyTest1(const MyTest1& myt);
};

MyTest1::MyTest1()
{
}

MyTest1::MyTest1(const MyTest1& myt)
{
}

MyTest1::~MyTest1()
{
}

MyTest1* MyTest1::getInstance()
{
    // 线程安全， 并且只会被初始化一次
    static MyTest1* t = new MyTest1;
    return t;
}
int main()
{
    MyTest1* t1 = MyTest1::getInstance();
    cout << t1 << endl;
    MyTest1* t2 = MyTest1::getInstance();
    cout << t2 << endl;
    system("pause");
    return EXIT_SUCCESS;
}