创建型模式：工厂模式（简单工厂模式，抽象工厂模式，工厂模式）

原创于 2015-09-13 10:43:43 发布 · 389 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了工厂模式及其两种形式：简单工厂模式和抽象工厂模式，并通过C++代码实例展示了如何实现这两种模式。简单工厂模式简化了对象创建的细节，而抽象工厂模式则支持不同类型的产品，提供了更灵活的使用方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

简单工厂模式

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

优点

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

2.客户端只需要知道用哪个工厂，提供的类型也可以用比较便于识别的字符串。

3.方便添加新的产品子类。

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

缺点

1.要求产品子类的类型差不多，使用的方法名都相同。

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

工厂模式

工厂模式基本与简单工厂模式差不多，简单工厂模式违背了开放-封闭原则，工厂模式解决了这个问题。

每当添加产品子类的时候，添加一个工厂子类，这遵循了开放-封闭原则。但如果产品数量足够多，要维护的量就会增加，好在工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

抽象工厂模式

工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，限制了产品子类的扩展。抽象工厂模式将同一类产品子类归为一类，将他们视作一组，然后好几组产品构成一族。

使用时客户端必须知道是哪一个工厂哪一组的产品抽象类。每一个工厂子类负责产生一族产品，工厂子类的一种方法产生一种类型的产品。

优点

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

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

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

缺点

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

2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，违背了开放-封闭原则。

简单工厂模式C++实现

AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_
#include <stdio.h>

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

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

class ProductB:public AbstractProduct {
public:
    ProductB();
    ~ProductB();
    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();
    virtual AbstractProduct* createProduct(int type) = 0;
};

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

SimpleFactory.cpp

#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;
}

工厂模式C++实现
AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_
#include <stdio.h>

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

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

class ProductB:public AbstractProduct {
public:
    ProductB();
    ~ProductB();
    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");
}

AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_
#include <stdio.h>
#include "AbstractProduct.h"

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

class FactoryA:public AbstractFactory {
public:
    FactoryA();
    ~FactoryA();
    AbstractProduct* createProduct();
};

class FactoryB:public AbstractFactory {
public:
    FactoryB();
    ~FactoryB();
    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;
}

抽象工厂模式C++实现

AbstractProductA.h
#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_
#include <stdio.h>

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

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

class ProductA_2:public AbstractProductA {
public:
    ProductA_2();
    ~ProductA_2();
    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();
    virtual void operationB() = 0;
};

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

class ProductB_2:public AbstractProductB {
public:
    ProductB_2();
    ~ProductB_2();
    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();
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

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

class Factory2:public AbstractFactory {
public:
    Factory2();
    ~Factory2();
    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;
}