抽象工厂模式和工厂方法

最新推荐文章于 2025-06-10 22:40:01 发布

tom555cat

最新推荐文章于 2025-06-10 22:40:01 发布

阅读量615

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ 设计模式文章标签：工厂模式智能指针

本文链接：https://blog.youkuaiyun.com/tom555cat/article/details/22992515

C++ 同时被 2 个专栏收录

32 篇文章

订阅专栏

设计模式

14 篇文章

订阅专栏

本文详细解释了工厂模式的三种类型——简单工厂模式、工厂方法模式和抽象工厂模式，并通过C++代码实例展示了如何在实际编程中应用这些模式。重点介绍了如何使用智能指针来管理资源，以及在工厂方法模式中如何通过子类决定实例化类。

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

所有的工厂模式都是用来封装对象的创建。

简单工厂模式：简单工厂模式算不上一种设计模式，是将创建对方的方法放在一个工厂类里边，客户需要一个工厂类的成员变量来实现创建对象。

工厂方法模式：

abstract Product factoryMethod(String type)

定义了一个创建对象的接口，通过子类决定该创建什么对象。工厂方法必须返回一个产品基类。

抽象工厂模式：创建一个工厂接口，用于创建相关对象家族，而不需要明确指定具体类。接口中每一个方法都是工厂方法。

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。共创方法让类把实例化推迟到子类。

IHumanFactory.h

#ifndef _IHUMANFACTORY
#define _IHUMANFACTORY
#include "IHuman.h"

class HumanFactory
{
public:
    HumanFactory() {}
    virtual ~HumanFactory() {}

    virtual Human* createHuman() = 0;
};

#endif // _IHUMANFACTORY

例如在上面的HumanFactory类中定义了一个工厂方法virtual Human* createHuman() = 0。这个工厂方法用来处理对象的创建，并将这样的行为封装在了子类中。

例如：

IBlackHumanFactory.h

#ifndef _IBLACKHUMANFACTORY
#define _IBLACKHUMANFACTORY
#include "IHumanFactory.h"
#include "IBlackHuman.h"

class BlackHumanFactory : public HumanFactory
{
public:
    BlackHumanFactory() {}
    ~BlackHumanFactory() {}

    Human* createHuman() { return new BlackHuman();}
};

#endif // _IBLACKHUMANFACTORY

BlackHumanFactory就是HumanFactory的子类，子类的Human* createHuman()来创建对象。

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象工厂的任务是定义一个负责创建一组产品的接口，这个接口内的每个方法都负责创建一个具体产品。

下面的例子中HumanFactory只有一个工厂方法。

类图如下所示：

代码如下。

IHuman.h

#ifndef _IHUMAN
#define _IHUMAN

class Human
{
public:
    Human() {};
    virtual ~Human() {};
    virtual void Laugh() = 0;
};

#endif // _IHUMAN

IBlackHuman.h

#ifndef _IBLACKHUMAN
#define _IBLACKHUMAN
#include "IHuman.h"

class BlackHuman : public Human
{
public:
    BlackHuman() {}
    ~BlackHuman() {}
    void Laugh() { std::cout<<"BlackHuman Laugh!"<<std::endl; }
};

#endif // _IBLACKHUMAN

IWhiteHuman.h

#ifndef _IWHITEHUMAN
#define _IWHITEHUMAN

#include "IHuman.h"

class WhiteHuman : public Human
{
public:
    WhiteHuman() {}
    ~WhiteHuman() {}
    void Laugh() { std::cout<<"WhiteHuman Laugh!"<<std::endl; }
};

#endif // _IWHITEHUMAN

工厂类：

IHumanFactory.h

#ifndef _IHUMANFACTORY
#define _IHUMANFACTORY
#include "IHuman.h"

class HumanFactory
{
public:
    HumanFactory() {}
    virtual ~HumanFactory() {}

    virtual Human* createHuman() = 0;
};

#endif // _IHUMANFACTORY

IBlackHumanFactory.h

#ifndef _IBLACKHUMANFACTORY
#define _IBLACKHUMANFACTORY
#include "IHumanFactory.h"
#include "IBlackHuman.h"

class BlackHumanFactory : public HumanFactory
{
public:
    BlackHumanFactory() {}
    ~BlackHumanFactory() {}

    Human* createHuman() { return new BlackHuman();}
};

#endif // _IBLACKHUMANFACTORY

IWhiteHumanFactory.h

#ifndef _IWHITEHUMANFACTORY
#define _IWHITEHUMANFACTORY
#include "IBlackHumanFactory.h"
#include "IWhiteHuman.h"

class WhiteHumanFactory : public HumanFactory
{
public:
    WhiteHumanFactory() {}
    ~WhiteHumanFactory() {}

    Human* createHuman() { return new WhiteHuman(); }
};
#endif // _IWHITEHUMANFACTORY

测试：

#include <iostream>
#include "IBlackHumanFactory.h"
#include "IWhiteHumanFactory.h"
#include "IBlackHuman.h"
#include "IWhiteHuman.h"

using namespace std;

int main()
{
    BlackHumanFactory bhf;
    WhiteHumanFactory whf;
    Human *bh = bhf.createHuman();
    Human *wh = whf.createHuman();
    bh->Laugh();
    wh->Laugh();
    return 0;
}

结果为：

BlackHuman Laugh!

WhiteHuman Laugh!

在“资源取得时机便是初始化时机”的指引下，我们采用智能指针来管理createHuman中的new创建的资源。

IHumanFactory.h

#ifndef _IHUMANFACTORY
#define _IHUMANFACTORY
#include <memory>
#include "IHuman.h"

class HumanFactory
{
public:
    HumanFactory() {}
    virtual ~HumanFactory() {}

    virtual std::shared_ptr<Human> createHuman() = 0;
};

#endif // _IHUMANFACTORY

IWhiteHumanFactory.h

#ifndef _IWHITEHUMANFACTORY
#define _IWHITEHUMANFACTORY
#include "IBlackHumanFactory.h"
#include "IWhiteHuman.h"

class WhiteHumanFactory : public HumanFactory
{
public:
    WhiteHumanFactory() {}
    ~WhiteHumanFactory() {}

    std::shared_ptr<Human> createHuman() { return std::make_shared<WhiteHuman>(); }
};
#endif // _IWHITEHUMANFACTORY

IBlackHumanFactory.h

#ifndef _IBLACKHUMANFACTORY
#define _IBLACKHUMANFACTORY
#include "IHumanFactory.h"
#include "IBlackHuman.h"

class BlackHumanFactory : public HumanFactory
{
public:
    BlackHumanFactory() {}
    ~BlackHumanFactory() {}

    std::shared_ptr<Human> createHuman() { return std::make_shared<BlackHuman>();}
};

#endif // _IBLACKHUMANFACTORY

test.cpp

#include <iostream>
#include "IBlackHumanFactory.h"
#include "IWhiteHumanFactory.h"
#include "IBlackHuman.h"
#include "IWhiteHuman.h"

using namespace std;

int main()
{
    BlackHumanFactory bhf;
    WhiteHumanFactory whf;
    shared_ptr<Human> bh = bhf.createHuman();
    shared_ptr<Human> wh = whf.createHuman();
    bh.get()->Laugh();
    wh.get()->Laugh();
    return 0;
}

其中bh.get()->Laugh()是将shared_ptr<Human>显示地转换为Human*。

从此以后class*我将替换为shared_ptr<class>，new替换为make_shared<class>()，至于delete就用不着操心了。