工厂模式

最新推荐文章于 2025-05-31 10:47:41 发布

原创最新推荐文章于 2025-05-31 10:47:41 发布 · 618 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式

设计模式专栏收录该内容

6 篇文章

订阅专栏

参考
设计模式又叫做面向对象的设计，使得代码可重复使用、可维护、可扩展、灵活性好。
为了提高内聚和松耦合，我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题是n多的子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如new ×××的代码。这里带来的问题是客户程序员必须知道实际子类的名称，并且后续维护会越来越复杂，甚至可能需要更改客户程序，这样对于客户程序来说很不友好，很复杂。

设计原则

开放-封闭原则：软件实体（类、模块、函数等等）应该尽量做到可以扩展，但是不可修改。做任何系统的时候，都不要指望系统一开始时需求确定，就再也不会变化，这是不现实也不科学的想法，而既然需求是一定会变化的，那么如何在面对需求的变化时，设计的软件可以相对容易修改，不至于说，新需求一来，就要把整个程序推倒重来。上述原则给了我们思路，设计软件就需要尽量多扩展少修改，这样才可以大大避免不必要的Bug产生。
设计类的时候，时刻要考虑，尽量让这个类是足够好。写好了就不要去修改了，如果新需求来，我们增加一些类就完事了，原来的代码能不动则不动。

简单工厂模式

工厂模式实际上是为了定义创建对象的接口，将多个对象的创建过程封装到一个类中，简化客户端程序的调用，而不需要直到内部的一些细节。
例如有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核，客户需要什么样的处理器核，一定要显示地告诉生产工厂，下面给出一种实现方案。

#include<iostream>
using namespace std;

class SingleCore{
public:
    virtual void show() = 0;//抽象基类仅仅为了定义接口
};

//单核A型号
class SingleCoreA: public SingleCore{
    void show(){
        cout << "SingleCoreA" << endl;
    }
};

//单核B型号
class SingleCoreB: public SingleCore{
    void show(){
        cout << "SingleCoreB" << endl;
    }
};

//唯一工厂，当有两个工厂的时候，这种模式就不方便使用了，所以需要使用抽象工程模式
class Factory{
public:
     SingleCore* CreateSingleCoreA(){
         return new SingleCoreA;
     }
     SingleCore* CreateSingleCoreB(){
         return new SingleCoreB;
     }
};
int main(void){
    Factory *factory = new Factory;//实例化工厂

    SingleCore* A = factory->CreateSingleCoreA();//通过工厂创建产品
    A->show();
    SingleCore* B = factory->CreateSingleCoreB();//通过工厂创建产品
    B->show();
    return 0;
}

抽象工厂模式

将工厂定义为抽象基类，及仅仅定义工厂需要实现的接口，具体的代码实现由具体的工厂去做。
例如这家工厂不仅可以生产单核处理器，也能生产多核处理器，抽象工厂模式就可以使用了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

#include<iostream>
using namespace std;

class SingleCore{
public:
    virtual void show() = 0;//抽象基类仅仅为了定义接口
};

//单核A型号
class SingleCoreA: public SingleCore{
    void show(){
        cout << "SingleCoreA" << endl;
    }
};

//单核B型号
class SingleCoreB: public SingleCore{
    void show(){
        cout << "SingleCoreB" << endl;
    }
};

class MultiCore{
public:
    virtual void show() = 0;//抽象基类仅仅为了定义接口
};

//多核A型号
class MultiCoreA: public MultiCore{
    void show(){
        cout << "MultiCoreA" << endl;
    }
};

//多核B型号
class MultiCoreB: public MultiCore{
    void show(){
        cout << "MultiCoreB" << endl;
    }
};

//抽象工程工厂，仅仅定义工厂的接口，具体由子类实现，最大限度实现代码可复用。
class AbstractFactory{
public:
    virtual SingleCore* CreateSingleCore() = 0;
    virtual MultiCore* CreateMultiCore() = 0;
};

//实例化两个工厂，一个A工厂，一个B工厂。这样创建对象仅仅调用工厂即可。
class FactoryA: public AbstractFactory{
public:
     SingleCore* CreateSingleCore(){
         return new SingleCoreA;
     }
     MultiCore* CreateMultiCore(){
         return new MultiCoreA;
     }
};

class FactoryB:public AbstractFactory{
public:
     SingleCore* CreateSingleCore(){
         return new SingleCoreB;
     }
     MultiCore* CreateMultiCore(){
         return new MultiCoreB;
     }
};
int main(void){
    AbstractFactory *factoryA = new FactoryA;//实例化A工厂,通过基类指针引用，实现多态
    AbstractFactory *factoryB = new FactoryB;//实例化B工厂,通过基类指针引用，实现多态

    SingleCore* SA = factoryA->CreateSingleCore();//通过工厂创建产品
    MultiCore* MA = factoryA->CreateMultiCore();
    SA->show();
    MA->show();

    SingleCore* SB = factoryB->CreateSingleCore();//通过工厂创建产品
    MultiCore* MB = factoryB->CreateMultiCore();
    SB->show();
    MB->show();

    return 0;
}