7、【C++】单例模式/工厂模式

其他 2018-11-04 20:11:09 阅读次数: 0

一、单例模式

    单例模式，可以说设计模式中最常应用的一种模式了，据说也是面试官最喜欢的题目。但是如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况，可能会优先考虑使用全局或者静态变量的方式，这样比较简单，也是没学过设计模式的人所能想到的最简单的方式了。

    一般情况下，我们建立的一些类是属于工具性质的，基本不用存储太多的跟自身有关的数据，在这种情况下，每次都去new一个对象，即增加了开销，也使得代码更加臃肿。其实，我们只需要一个实例对象就可以。如果采用全局或者静态变量的方式，会影响封装性，难以保证别的代码不会对全局变量造成影响。

    考虑到这些需要，我们将默认的构造函数声明为私有的，这样就不会被外部所new了，甚至可以将析构函数也声明为私有的，这样就只有自己能够删除自己了。在Java和C#这样纯的面向对象的语言中，单例模式非常好实现，直接就可以在静态区初始化instance，然后通过getInstance返回，这种就被称为饿汉式单例类。也有些写法是在getInstance中new instance然后返回，这种就被称为懒汉式单例类，但这涉及到第一次getInstance的一个判断问题。

单线程中

Singleton* getInstance()
{
    if (instance == NULL)
        //饿汉式单例模式（直接在getInstance函数中new一个instance，然后返回）
        instance = new Singleton();//懒汉式单例模式
 
    return instance;
}

    这样就可以了，保证只取得了一个实例。但是在多线程的环境下却不行了，因为很可能两个线程同时运行到if (instance == NULL)这一句，导致可能会产生两个实例。于是就要在代码中加锁。

Singleton* getInstance()
{
    lock();
    if (instance == NULL)
    {
       instance = new Singleton();
    }
    unlock();

    return instance;
}

    但这样写的话，会稍稍映像性能，因为每次判断是否为空都需要被锁定，如果有很多线程的话，就爱会造成大量线程的阻塞。于是大神们又想出了双重锁定。

Singleton* getInstance()
{
    if (instance == NULL)
    {
    lock();
        if (instance == NULL)
        {
               instance = new Singleton();
        }
        unlock();
    }

    return instance;
}

    这样只够极低的几率下，通过越过了if (instance == NULL)的线程才会有进入锁定临界区的可能性，这种几率还是比较低的，不会阻塞太多的线程，但为了防止一个线程进入临界区创建实例，另外的线程也进去临界区创建实例，又加上了一道防御if (instance == NULL)，这样就确保不会重复创建了。

常用的场景

    单例模式常常与工厂模式结合使用，因为工厂只需要创建产品实例就可以了，在多线程的环境下也不会造成任何的冲突，因此只需要一个工厂实例就可以了。
优点：
    1.减少了时间和空间的开销（new实例的开销）。
    2.提高了封装性，使得外部不易改动实例。
缺点：
    1.懒汉式是以时间换空间的方式。（在getInstance中new instance然后返回）
    2.饿汉式是以空间换时间的方式。（在静态区初始化instance，然后通过getInstance返回）

【示例】饿汉单例模式

//Singleton.h
#ifndef _SINGLETON_H_
#define _SINGLETON_H_

class Singleton{
public:
    static Singleton* getInstance();//声明静态成员函数

private:
    Singleton();
    //把复制构造函数和=操作符也设为私有,防止被复制
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    //在静态区定义并初始化实例
    static Singleton* instance;//声明静态成员变量
};

#endif

//Singleton.cpp
#include "Singleton.h"

Singleton::Singleton(){

}

Singleton::Singleton(const Singleton&){

}

Singleton& Singleton::operator=(const Singleton&){

}

//定义并初始化静态成员变量
Singleton* Singleton::instance = new Singleton();
//定义静态成员函数
Singleton* Singleton::getInstance(){
    return instance;
}

//main.cpp
#include "Singleton.h"
#include <stdio.h>

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

    if (singleton1 == singleton2)
        fprintf(stderr,"singleton1 = singleton2\n");

    return 0;
}

    执行结果：

    singleton1 = singleton2

二、工厂模式

    C++的工厂模式分为三种：简单工厂模式、工厂模式和抽象工厂模式

一、简单工厂模式

    简单工厂模式是工厂模式中最简单的一种，他可以用比较简单的方式隐藏创建对象的细节，一般只需要告诉工厂类所需要的类型，工厂类就会返回需要的产品类，但客户端看到的只是产品的抽象对象，无需关心到底是返回了哪个子类。客户端唯一需要知道的具体子类就是工厂子类。除了这点，基本是达到了依赖倒转原则的要求。

    假如，我们不用工厂类，只用AbstractProduct和它的子类，那客户端每次使用不同的子类的时候都需要知道到底是用哪一个子类，当类比较少的时候还没什么问题，但是当类比较多的时候，管理起来就非常的麻烦了，就必须要做大量的替换，一个不小心就会发生错误。

    而使用了工厂类之后，就不会有这样的问题，不管里面多少个类，我只需要知道类型号即可。不过，这里还有一个疑问，那就是如果我每次用工厂类创建的类型都不相同，这样修改起来的时候还是会出现问题，还是需要大量的替换。所以简单工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

常用的场景

    例如部署多种数据库的情况，可能在不同的地方要使用不同的数据库，此时只需要在配置文件中设定数据库的类型，每次再根据类型生成实例，这样，不管下面的数据库类型怎么变化，在客户端看来都是只有一个AbstractProduct，使用的时候根本无需修改代码。提供的类型也可以用比较便于识别的字符串，这样不用记很长的类名，还可以保存为配置文件。

    这样，每次只需要修改配置文件和添加新的产品子类即可。

    所以简单工厂模式一般应用于多种同类型类的情况，将这些类隐藏起来，再提供统一的接口，便于维护和修改。

优点

    1.隐藏了对象创建的细节，将产品的实例化推迟到子类中实现。

    2.客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂就行了，提供的类型也可以用比较便于识别的字符串。

    3.方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。

    4.遵循了依赖倒转原则。

缺点

    1.要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，而所有的类又必须要添加一种方法，则会是非常麻烦的事情。或者是一种类另一种类有几种方法不相同，客户端无法知道是哪一个产品子类，也就无法调用这几个不相同的方法。

    2.每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。

【示例】

//AbstractProduct.h
#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_

#include <stdio.h>
//抽象类
class AbstractProduct{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct{
public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct{
public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

//AbstractProduct.cpp
#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){
}
AbstractProduct::~AbstractProduct(){
}

ProductA::ProductA(){
}
ProductA::~ProductA(){
}
void ProductA::operation(){
    fprintf(stderr,"productA operation!\n");
}

ProductB::ProductB(){
}
ProductB::~ProductB(){
}
void ProductB::operation(){
    fprintf(stderr,"productB operation!\n");
}

//SimpleFactory.h
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct(int type) = 0;    
};

class SimpleFactory:public AbstractFactory{
public:
    SimpleFactory();
    ~SimpleFactory();
    
public:
    AbstractProduct* createProduct(int type);
};

#endif

#include "SimpleFactory.h"

AbstractFactory::AbstractFactory(){
}
AbstractFactory::~AbstractFactory(){
}

SimpleFactory::SimpleFactory(){
}
SimpleFactory::~SimpleFactory(){
}

AbstractProduct* SimpleFactory::createProduct(int type){
    AbstractProduct* temp = NULL;
    switch(type)
    {
    case 1:
        temp = new ProductA();
        break;
    case 2:
        temp = new ProductB();
        break;
    default:
        break;
    }
    return temp;
}

//client.cpp
#include "SimpleFactory.h"

int main(){
    AbstractFactory* factory = new SimpleFactory();
    AbstractProduct* product = factory->createProduct(1);
    product->operation();
    delete product;
    product = NULL;
    
    product = factory->createProduct(2);
    product->operation();
    delete product;
    product = NULL;
    return 0;
}
二、工厂模式

    工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

    既然每次都要判断，那我就把这些判断都生成一个工厂子类，这样，每次添加产品子类的时候，只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题，如果产品数量足够多，要维护的量就会增加，好在一般工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

    同样工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

常用的场景

    基本与简单工厂模式一致，只不过是改进了简单工厂模式中的开放-封闭原则的缺陷，使得模式更具有弹性。将实例化的过程推迟到子类中，由子类来决定实例化哪个。

优点：

    基本与简单工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强
缺点：

    与简单工厂模式差不多。
【示例】

//AbstractProduct.h
#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_

#include <stdio.h>

class AbstractProduct{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct{
public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct{
public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

//AbstractProduct.h
#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){
}
AbstractProduct::~AbstractProduct(){
}

ProductA::ProductA(){
}
ProductA::~ProductA(){
}
void ProductA::operation(){
    fprintf(stderr,"productA operation!\n");
}

ProductB::ProductB(){
}
ProductB::~ProductB(){
}
void ProductB::operation(){
    fprintf(stderr,"productB operation!\n");
}

//AbstractFactory.h
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"


class AbstractFactory{

public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct() = 0;    
};


class FactoryA:public AbstractFactory{

public:
    FactoryA();
    ~FactoryA();
    
public:
    AbstractProduct* createProduct();
};


class FactoryB:public AbstractFactory{

public:
    FactoryB();
    ~FactoryB();
    
public:
    AbstractProduct* createProduct();
};
#endif

//AbstractFactory.cpp
#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(){
}
AbstractFactory::~AbstractFactory(){
}

FactoryA::FactoryA(){
}
FactoryA::~FactoryA(){
}
AbstractProduct* FactoryA::createProduct(){
    AbstractProduct* temp = NULL;
    temp = new ProductA();
    return temp;
}

FactoryB::FactoryB(){
}
FactoryB::~FactoryB(){
}
AbstractProduct* FactoryB::createProduct(){
    AbstractProduct* temp = NULL;
    temp = new ProductB();
    return temp;
}

//client.cpp
#include "AbstractFactory.h"

int main(){
    AbstractFactory* factory = new FactoryA();
    AbstractProduct* product = factory->createProduct();
    product->operation();
    delete product;
    product = NULL;
    delete factory;
    factory = NULL;
    
    factory = new FactoryB();
    product = factory->createProduct();
    product->operation();
    delete product;
    product = NULL;
    delete factory;
    factory = NULL;
    return 0;
}
三、抽象工厂模式

    抽象工厂模式就变得比工厂模式更为复杂，就像上面提到的缺点一样，工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，我们可以把他们一起视作一组，然后好几组产品构成一族。

    此时，客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品，而子类的一种方法产生一种类型的产品。在客户端看来只有AbstractProductA和AbstractProductB两种产品，使用的时候也是直接使用这两种产品。而通过工厂来识别是属于哪一族产品。

    产品ProductA_1和ProductB_1构成一族产品，对应于有Factory1来创建，也就是说Factory1总是创建的ProductA_1和ProductB_1的产品，在客户端看来只需要知道是哪一类工厂和产品组就可以了。一般来说， ProductA_1和ProductB_1都是适应同一种环境的，所以他们会被归为一族。

常用的场景

    例如Linux和windows两种操作系统下，有2个挂件A和B，他们在Linux和Windows下面的实现方式不同，Factory1负责产生能在Linux下运行的挂件A和B，Factory2负责产生能在Windows下运行的挂件A和B，这样如果系统环境发生变化了，我们只需要修改工厂就行了。

优点

    1.封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。

    2.可以支持不同类型的产品，使得模式灵活性更强。

    3.可以非常方便的使用一族中间的不同类型的产品。

缺点

    1.结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

    2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。
【示例】

//AbstractProductA.h
#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_

#include <stdio.h>

class AbstractProductA{
public:
    AbstractProductA();
    virtual ~AbstractProductA();
    
public:
    virtual void operationA() = 0;
};
class ProductA_1:public AbstractProductA{
public:
    ProductA_1();
    virtual ~ProductA_1();
    
public:
    void operationA();
};
class ProductA_2:public AbstractProductA{
public:
    ProductA_2();
    ~ProductA_2();
    
public:
    void operationA();
};

#endif

//AbstractProductA.cpp
#include "AbstractProductA.h"

AbstractProductA::AbstractProductA(){
}
AbstractProductA::~AbstractProductA(){
}

ProductA_1::ProductA_1(){
}
ProductA_1::~ProductA_1(){
}
void ProductA_1::operationA(){
    fprintf(stderr,"productA_1 operation!\n");
}

ProductA_2::ProductA_2(){
}
ProductA_2::~ProductA_2(){
}
void ProductA_2::operationA(){
    fprintf(stderr,"productA_2 operation!\n");
}

//AbstractProductB.h
#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_

#include <stdio.h>

class AbstractProductB{
public:
    AbstractProductB();
    virtual ~AbstractProductB();
    
public:
    virtual void operationB() = 0;
};

class ProductB_1:public AbstractProductB{
public:
    ProductB_1();
    virtual ~ProductB_1();
    
public:
    void operationB();
};

class ProductB_2:public AbstractProductB{
public:
    ProductB_2();
    ~ProductB_2();
    
public:
    void operationB();
};
#endif

//AbstractProductB.cpp
#include "AbstractProductB.h"

AbstractProductB::AbstractProductB(){
}
AbstractProductB::~AbstractProductB(){
}

ProductB_1::ProductB_1(){
}
ProductB_1::~ProductB_1(){
}
void ProductB_1::operationB(){
    fprintf(stderr,"productB_1 operation!\n");
}

ProductB_2::ProductB_2(){
}
ProductB_2::~ProductB_2(){
}
void ProductB_2::operationB(){
    fprintf(stderr,"productB_2 operation!\n");
}

//AbstractFactory.h
#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProductA.h"
#include "AbstractProductB.h"

class AbstractFactory{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProductA* createProductA() = 0;    
    virtual AbstractProductB* createProductB() = 0;    
};

class Factory1:public AbstractFactory{
public:
    Factory1();
    ~Factory1();
    
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

class Factory2:public AbstractFactory{
public:
    Factory2();
    ~Factory2();
    
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};
#endif

//AbstractFactory.cpp
#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(){
}
AbstractFactory::~AbstractFactory(){
}

Factory1::Factory1(){
}
Factory1::~Factory1(){
}
AbstractProductA* Factory1::createProductA(){
    AbstractProductA* temp = NULL;
    temp = new ProductA_1();
    return temp;
}
AbstractProductB* Factory1::createProductB(){
    AbstractProductB* temp = NULL;
    temp = new ProductB_1();
    return temp;
}

Factory2::Factory2(){
}
Factory2::~Factory2(){
}
AbstractProductA* Factory2::createProductA(){
    AbstractProductA* temp = NULL;
    temp = new ProductA_2();
    return temp;
}
AbstractProductB* Factory2::createProductB(){
    AbstractProductB* temp = NULL;
    temp = new ProductB_2();
    return temp;
}

//client.cpp
#include "AbstractFactory.h"

int main(){
    AbstractFactory* factory = new Factory1();
    AbstractProductA* productA = factory->createProductA();
    AbstractProductB* productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = NULL;
    delete productA;
    productA = NULL;
    delete productB;
    productB = NULL;
    
    factory = new Factory2();
    productA = factory->createProductA();
    productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = NULL;
    delete productA;
    productA = NULL;
    delete productB;
    productB = NULL;
    return 0;
}

猜你喜欢

转载自blog.csdn.net/sinat_33924041/article/details/83621256
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022