设计模式-创建型模式-单例模式

工程源码：C++设计模式-单例模式https://download.csdn.net/download/qq_40788199/85539072

码云：

https://gitee.com/gongguixing/c-design-mode.githttps://gitee.com/gongguixing/c-design-mode.git 

1、单例模式的定义与特点

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

单例模式有 3 个特点：

1. 单例类只有一个实例对象；
2. 该单例对象必须由单例类自行创建；
3. 单例类对外提供一个访问该单例的全局访问点。

2、单例模式的优点和缺点

单例模式的优点：

• 单例模式可以保证内存里只有一个实例，减少了内存的开销。
• 可以避免对资源的多重占用。
• 单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点：

• 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

3、单例模式的结构

单例模式的主要角色如下。

• 单例类：包含一个实例且能自行创建这个实例的类。
• 访问类：使用单例的类。

​

4、单例模式的实现

单例模式有两种实现方式，一种是懒汉式，一种是饿汉式。

单例模式还涉及线程安全问题，下篇文章讲解单例模式的线程安全问题。

4.1懒汉式单例

该模式的特点是类加载时没有生成单例，只有当第一次调用 lnstance 方法时才去创建这个单例。

代码：

#ifndef CLAZYSINGLETON_H
#define CLAZYSINGLETON_H


class CLazySingleton
{

private:
    // 构造函数私有，禁止外部创建，释放
    CLazySingleton();
    ~CLazySingleton();
public:
    // 静态方法，全局访问
    static CLazySingleton * instance();
    void say();
};

#endif // CLAZYSINGLETON_H

#include "clazysingleton.h"
#include "iostream"

CLazySingleton::CLazySingleton()
{
    // 打印字符，观察对象合时被实例化，被实例化多少次？
    std::cout << "constructor" << std::endl;
}

CLazySingleton::~CLazySingleton()
{

}

CLazySingleton *CLazySingleton::instance()
{
    // 类内创建对象
    // 使用静态对象，保证对象只会被创建一次
    // 此方法已经线程安全
    std::cout << "instance" << std::endl;
    static CLazySingleton * p = new CLazySingleton();
    return p;
}

void CLazySingleton::say()
{
    std::cout << "I am LazySingleton!" << std::endl;
}

 调用例子：

#include <iostream>
#include <clazysingleton.h>

void lazySingleton()
{
    // 获取对象指针再执行say
    CLazySingleton::instance()->say();

    // 即使多次调用也不会创建多个对象
    std::cout << "Object address 1: " << CLazySingleton::instance() << std::endl;
    std::cout << "Object address 2: " << CLazySingleton::instance() << std::endl;
}


int main()
{
    std::cout << "main begin" << std::endl;
    lazySingleton();
    return 0;
}

 ​

 如图所示，多次调用instance，对象地址一致，无论调用多少次instance，对象只会被实例化一次，且对象的实例化是在main函数之后的。

4.2饿汉式

该模式的特点是类一旦加载就创建一个单例，保证在调用 Instance 方法之前单例已经存在了。

代码：

#ifndef CHUNGERSINGLETON_H
#define CHUNGERSINGLETON_H


class CHungerSingleton
{
private:
    // 构造函数私有，禁止外部创建，释放
    CHungerSingleton();
    ~CHungerSingleton();

private:
    // 静态成员变量指针私有
    static CHungerSingleton *g_p;

public:
    // 静态方法，全局访问
    static CHungerSingleton * instance();
    void say();
};

#include "chungersingleton.h"
#include "iostream"

// 对象在cpp文件构造，禁止外部直接访问
CHungerSingleton * CHungerSingleton::g_p = new CHungerSingleton();

CHungerSingleton::CHungerSingleton()
{
    // 打印字符，观察对象合时被实例化，被实例化多少次？
    std::cout << "constructor" << std::endl;
}

CHungerSingleton::~CHungerSingleton()
{

}

CHungerSingleton *CHungerSingleton::instance()
{
    // 对象已经创建好必然，线程安全
    std::cout << "instance" << std::endl;
    return g_p;
}

void CHungerSingleton::say()
{
    std::cout << "I am HungerSingleton!" << std::endl;
}

调用例子

#include <iostream>
#include "chungersingleton.h"

void hungerSingleton()
{
    // 获取对象指针再执行say
    CHungerSingleton::instance()->say();

    // 即使多次调用也不会创建多个对象
    std::cout << "Object address 1: " << CHungerSingleton::instance() << std::endl;
    std::cout << "Object address 2: " << CHungerSingleton::instance() << std::endl;
}


int main()
{
    std::cout << "main begin" << std::endl;
    hungerSingleton();
    return 0;
}

 ​

  如图所示，饿汉式的构造函数在main函数执行之前，因此是线程安全，在类外构造，肯定只有一个对象。