单例模式又叫做单件模式，它的核心定义是：保证一个类在一个程序只有一个实例存在，同时至少提供一个能访问该实例的全局方法。例如我们Windows电脑中的任务管理器，在整个系统运行期间，只存在一个任务管理器的实例。为了保证该类只存在一个实例，在定义该类时，需要将类的构造函数置为private权限。


它有两种实现方式，分别是饿汉式和懒汉式，示例代码如下：

懒汉式：

#include <iostream>
using namespace std;

class Singleton {
public:
    static Singleton* getInstance() 
    {
        if (!_instance) 
        {
            /* 在此实例化对象 */
            _instance = new Singleton();
        }
        return _instance;
    }

    ~Singleton() 
    {
        delete _instance；
        cout << "~Singleton..." << endl;
    }

private:
    Singleton() 
    {
        cout << "Singleton..." << endl;
    }

    static Singleton* _instance;
};

Singleton* Singleton::_instance = NULL;

int main() 
{
    Singleton *singleton1 = Singleton::getInstance();
    cout << singleton1 << endl;
    Singleton *singleton2 = Singleton::getInstance();
    cout << singleton2 << endl;

    

    return 0;
}

运行结果如下：

饿汉式：

#include <iostream>

using namespace std;


class Singelton
{
private:
	Singelton()
	{
		cout << "Singelton 构造函数执行" << endl;
	}

public:
	/* 全局获取单例接口 */
	static Singelton *getInstance()
	{
		return m_ps1;
	}

private:
	static Singelton *m_ps1;

};

/* 在此实例化对象 */
Singelton *Singelton::m_ps1 = new Singelton;

void main()
{
	printf("\n");
	Singelton *p1 = Singelton::getInstance();
	Singelton *p2 = Singelton::getInstance();

	if (p1 == p2)
	{
		cout << "是同一个对象" << endl;
	}
	else
	{
		cout << "不是同一个对象" << endl;
	}
	
	system("pause");

	return;
}

运行结果如下：


懒汉式的多线程问题

  • 程序每次调用getInstance( )静态方法时，必须判断NULL==_instance，是程序开销增大。

  • 在多线程编程时，因为C++中的构造函数并不是线程安全的。所以程序中可能会导致多个实例的产生，从而导致代码运行不正确，以及产生内存泄漏。

  • 类中必须实现类的析构函数，而饿汉式则不需要，因为静态变量是在main()之前初始化的，而且在程序执行完毕后，会由系统自行进行回收，所以不需要实现它的析构函数。