【HeadFirst 设计模式】工厂模式的C++实现

于 2024-08-14 23:26:51 发布
阅读量170 收藏 2
点赞数 3
分类专栏： 设计模式 文章标签： c++ 设计模式 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43717839/article/details/141202731
版权

文章目录

简单工厂模式

一、案例背景

你是小镇上最有名的一家披萨店的店主，你们店里的披萨广受人们喜爱。你们的订单系统是这么写的：

Pizza* orderPizza(string type)
{
    Pizza* pizza {};

    if (type == "cheese")
    {
        pizza = new CheesePizza();
    }
    else if (type == "greek")
    {
        pizza = new greekPizza();
    }
    else if (type == "pepperoni")
    {
        pizza = new PepperoniPizza();
    }

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
}

二、案例分析

看起来很正常。但是压力来自于增加更多的披萨类型。你发现你所有的竞争者都已经在他们的菜单中加入了一些流行风味的披萨，很明显，你必须要赶上他们，所以你也要将这些类型的披萨加进你的菜单中，而最近Greek Pizza卖的不好，所以你决定将它从菜单中去掉。

#include <iostream>
#include <string>
using namespace std;

Pizza* orderPizza(string type)
{
    Pizza* pizza {};

    if (type == "cheese")
    {
        pizza = new CheesePizza();
    }
    //else if (type == "greek")
    //{
    //    pizza = new greekPizza();
    //}
    else if (type == "pepperoni")
    {
        pizza = new PepperoniPizza();
    }
    else if (type == "clam")
    {
        pizza = new ClamPizza();
    }
    else if (type == "veggie")
    {
        pizza = new VeggiePizza();
    }

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
}

前面提到过一个“开闭原则”，很明显地，如果实例化“某些”具体类，将使orderPizza（）出问题，而且也无法让orderPizza（）对修改关闭，但是，现在我们已经知道哪些会改变，哪些不会改变，是时候使用封装了。

现在最好将创建对象移到orderPizza()之外，但是怎么做呢？要把创建披萨的代码移到另一个对象中，由这个新对象专职创建披萨。

三、代码分析

看了代码实现之后，你可能会想：简单工厂模式看起来“简单”了，简单的不像个设计模式。这样做有什么好处？似乎只是把问题搬到另一个对象里罢了，问题依然存在。别忘了，SimplePizzaFactory可以有很多客户，虽然目前只看到了订单系统对齐进行了调用，但是，可能还有其他类利用这个工厂获取披萨的价钱和描述。

class SimplePizzaFactory
{
public:
    Pizza* createPizza(const String& type)
    {
        Pizza* pizza {};

        if (type == "cheese")
        {
            pizza = new CheesePizza();
        }
        else if (type == "greek")
        {
            pizza = new greekPizza();
        }
        else if (type == "pepperoni")
        {
            pizza = new PepperoniPizza();
        }
        else if (type == "clam")
        {
            pizza = new ClamPizza();
        }
        else if (type == "veggie")
        {
            pizza = new VeggiePizza();
        }

        return pizza;
    }
};
Pizza* orderPizza(string type)
{
    Pizza* pizza = SimplePizzaFactory().createPizza(type);

    pizza->prepare();
    pizza->bake();
    pizza->cut();
    pizza->box();

    return pizza;
}

工厂方法模式

一、案例背景

你的披萨店经营有成，击败了竞争者，现在大家都希望加盟你的店。身为加盟公司的经营者，你希望确保加盟店营运的质量，所以希望这些店都使用你那些经得起时间考验的代码。

在这个过程中，你发现加盟店的确是采用你的工厂创建披萨，但是其他部分，却开始采用他们自己根据当地人的口味做的一些改良：烘焙手法有些差异等等。再想想这个问题，你真的希望能够建立一个框架，把加盟店和创建披萨捆绑在一起的同时又保持一定的弹性。

二、案例分析

如果你已经学习过之前的设计模式，想必一定已经对面向接口编程有了一定的理解。既然我们想要根据不同的披萨店定制个性化的披萨，那就简单干脆一些，写出一个工厂父类，然后实现好几个具体工厂继承它，这样在创建的时候我们便能够动态的选择不同的工厂去制作披萨。

这样做确实可以，但是从不同的工厂获取原材料就意味着你对披萨的质量失去了一定的控制。这里提出另外一种做法：将工厂不再抽象为一个接口，而是抽象为一个方法，由这个方法获得具体的披萨实例。代码轮廓大概是这样的：

class PizzaStore
{
public:
    pizza orderPizza(const String& type)
    {
        Pizza pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
    virtual Pizza createPizza(const string& type) const = 0;
};

然后由具体的子类继承并实现自己需要的createPizza接口，这样一来，顾客决定到哪一家披萨店下订单才决定了披萨的风味。

三、代码分析

这里给出工厂方法模式的相关案例：

#include <iostream>
#include <string>
using namespace std;

class Pizza
{   // 这里省略具体细节
public:
    void prepare() {}
    void bake() {}
    void cut() {}
    void box() {}
};

class NYStylePizza : public Pizza
{
};
class NYStyleVeggiePizza : public Pizza
{
};
class NYStylePepperoniPizza : public Pizza
{
};

class ChicagoStylePizza : public Pizza
{
};
class ChicagoStyleVeggiePizza : public Pizza
{
};
class ChicagoStylePepperoniPizza : public Pizza
{
};

class PizzaStore
{
public:
    Pizza* orderPizza(const string& type)
    {
        Pizza* pizza = createPizza(type);

        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();

        return pizza;
    }
    virtual Pizza* createPizza(const string& type) const = 0;
};

class NYPizzaStore : public PizzaStore
{
    Pizza* createPizza(const string& type) const override
    {
        if (type == "cheese")
        {
            return new NYStylePizza();
        }
        else if (type == "veggie")
        {
            return new NYStyleVeggiePizza();
        }
        else if (type == "clam")
        {
            return new NYStylePepperoniPizza();
        }
        else
        {
            return nullptr;
        }
    }
};

class ChicagoPizzaStore : public PizzaStore
{
    Pizza* createPizza(const string& type) const override
    {
        if (type == "cheese")
        {
            return new ChicagoStylePizza();
        }
        else if (type == "veggie")
        {
            return new ChicagoStyleVeggiePizza();
        }
        else if (type == "clam")
        {
            return new ChicagoStylePepperoniPizza();
        }
        else
        {
            return nullptr;
        }
    }
};

int main()
{
    // 定制一个纽约风味的披萨
    Pizza* NYStyle      = (new NYPizzaStore())->orderPizza("cheese");
    // 定制一个芝加哥风味的披萨
    Pizza* ChicagoStyle = (new ChicagoPizzaStore())->orderPizza("cheese");
    return 0;
}

抽象工厂模式

一、案例背景

现在，披萨店的加盟生意如火如荼，但是随着时间的流逝，一些加盟店开始使用低价的原材料来增加利润。你必须采取一些手段，以免长此以往砸了自己的招牌。

如何确保所有加盟店的原材料使用高质量的原材料呢？你打算建造一家生产原料的工厂，并将原材料送到各家加盟店。

二、案例分析

现在，我们要建造一个工厂来生产原料，这个工厂将负责创建原料家族的每一种原料。也就是说，工厂还需要生产面团，酱料等。

先为工厂定义一个接口，这个接口负责创建所有品类的原材料：

class PizzaIngredientFactory
{
public:
    virtual Dough*   createDough()   = 0;
    virtual Sauce*   createSauce()   = 0;
    virtual Cheese*  createCheese()  = 0;
    virtual Veggies* createVeggies() = 0;
    virtual Clams*   createClams()   = 0;
};

然后创建具体的工厂实现：

class NYPizzaIngredientFactory : public PizzaIngredientFactory
{
    Dough* createDough() override
    {
        return new ThinCrustDough();
    }
    Sauce* createSauce() override
    {
        return new MarinaraSauce();
    }
    Cheese* createCheese() override
    {
        return new ReggianoCheese();
    }
    Veggies* createVeggies() override
    {
        return new NYVeggies();
    }
    Clams* createClams() override
    {
        return new FreshClams();
    }
};

之后就是将这些工厂与原来的代码进行合并。

三、代码分析

这里给出抽象工厂模式的相关案例：

#include <iostream>
#include <string>
using namespace std;

class Dough
{
};
class ThinCrustDough : public Dough
{
};
class Sauce
{
};
class MarinaraSauce : public Sauce
{
};
class Cheese
{
};

class ReggianoCheese : public Cheese
{
};
class Veggies
{
};
class NYVeggies : public Veggies
{
};
class Clams
{
};
class FreshClams : public Clams
{
};

class PizzaIngredientFactory
{
public:
    virtual Dough*   createDough()   = 0;
    virtual Sauce*   createSauce()   = 0;
    virtual Cheese*  createCheese()  = 0;
    virtual Veggies* createVeggies() = 0;
    virtual Clams*   createClams()   = 0;
};

class NYPizzaIngredientFactory : public PizzaIngredientFactory
{
public:
    Dough* createDough() override
    {
        return new ThinCrustDough();
    }
    Sauce* createSauce() override
    {
        return new MarinaraSauce();
    }
    Cheese* createCheese() override
    {
        return new ReggianoCheese();
    }
    Veggies* createVeggies() override
    {
        return new NYVeggies();
    }
    Clams* createClams() override
    {
        return new FreshClams();
    }
};

class Pizza
{
protected:
    string   name    = nullptr;
    Dough*   dough   = nullptr;
    Sauce*   sauce   = nullptr;
    Cheese*  cheese  = nullptr;
    Veggies* veggies = nullptr;
    Clams*   clams   = nullptr;

public:
    virtual void prepare() = 0;
    void         bake() {}
    void         cut() {}
    void         box() {}

    string getName()
    {
        return name;
    }
    void setName(string name)
    {
        name = name;
    }
};

class CheesePizza : public Pizza
{
private:
    PizzaIngredientFactory* factory;

public:
    CheesePizza(PizzaIngredientFactory* factory) : factory(factory) {}
    void prepare() override   // 神奇的事情在这里发生
    {
        name    = "Cheese Pizza";
        dough   = factory->createDough();
        sauce   = factory->createSauce();
        cheese  = factory->createCheese();
        veggies = factory->createVeggies();
        clams   = factory->createClams();
    }
};

class ClamPizza : public Pizza
{
private:
    PizzaIngredientFactory* factory;

public:
    ClamPizza(PizzaIngredientFactory* factory) : factory(factory) {}
    void prepare() override   // ClamPizza的原料在这里拿到
    {
        name    = "Clam Pizza";
        cheese  = factory->createCheese();
        veggies = factory->createVeggies();
        clams   = factory->createClams();
    }
};

class PizzaStore
{
public:
    Pizza* orderPizza(const string& type)
    {
        Pizza* pizza = createPizza(type);

        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();

        return pizza;
    }
    virtual Pizza* createPizza(const string& type) const = 0;
};

class NYPizzaStore : public PizzaStore
{
public:
    Pizza* createPizza(const string& type) const override
    {
        Pizza*                  pizza           = nullptr;
        PizzaIngredientFactory* instanceFactory = new NYPizzaIngredientFactory();

        if (type == "cheese")
        {
            pizza = new CheesePizza(instanceFactory);
            pizza->setName("New York Style Cheese Pizz");
        }
        else if (type == "clam")
        {
            pizza = new ClamPizza(instanceFactory);
            pizza->setName("New York Style Clam Pizz");
        }

        return pizza;
    }
};

int main()
{
    // 定制一个纽约风味的披萨
    Pizza* NYStyle = (new NYPizzaStore())->orderPizza("cheese");
    return 0;
}
隐居的遮天恶鬼
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
head first 设计模式-C++实现.zip
01-23
《Head First 设计模式》是一本非常受欢迎的设计模式学习书籍，它通过直观、生动的方式讲解了23种经典的GOF设计模式。这本书原本是用Java语言来解释这些模式的，但这里我们有一个C++实现的版本，这为C++开发者提供了...
C++实现HeadFirst策略模式设计模式
12-22
　Head First设计模式中介绍策略模式时以Duck类作为样例。当中用flyBehavior和quackBehavior两个接口引用变量代表鸭子飞行和鸭子叫这两种行为，通过改变flyBehavior和quackBehavior来满足不同的Duck子类的不同行为...
C++设计模式--状态模式解析(head first 设计模式C++实现)
qq_42292775的博客
09-17 422
【代码】C++设计模式--状态模式解析(head first 设计模式C++实现)
【设计模式】Head First 设计模式——桥模式 C++实现
Friday
08-30 954
设计模式最大的作用就是在变化和稳定中间寻找隔离点，然后分离它们，从而管理变化。将变化像小兔子一样关到笼子里，让它在笼子里随便跳，而不至于跳出来把你整个房间给污染掉。
【设计模式】Head First 设计模式——工厂方法模式 C++实现
Friday
08-31 989
设计模式最大的作用就是在变化和稳定中间寻找隔离点，然后分离它们，从而管理变化。将变化像小兔子一样关到笼子里，让它在笼子里随便跳，而不至于跳出来把你整个房间给污染掉。
【设计模式】Head First 设计模式——策略模式 C++实现
Friday
08-28 961
设计模式最大的作用就是在变化和稳定中间寻找隔离点，然后分离它们，从而管理变化。将变化像小兔子一样关到笼子里，让它在笼子里随便跳，而不至于跳出来把你整个房间给污染掉。
C++设计模式--迭代器模式组合模式解析(head first 设计模式C++实现)
qq_42292775的博客
09-17 362
【代码】C++设计模式--迭代器模式组合模式解析(head first 设计模式C++实现)
《headfirst设计模式》读书总结-包含C++代码
qq_46470984的博客
02-15 994
背景介绍： 假期期间阅读《HeadFirst设计模式》这本书，这本书写的很不错，内容生动不枯燥非常适合新手学习设计模式。在阅读之后我便写下了这本书的读书笔记，并将部分java代码用C++进行实现，感觉收获很多。 GitHub网站上我放有java代码、C++代码和书本的pdf 有兴趣的同学可以进行观看 GitHub：https://github.com/fightingzxd/HeadFirst 下面是我对每一章进行的总结，方便我日后进行复习，有兴趣的同学也可以看一下哟！链接如下： 《headfirst
《Head First 设计模式》例子的C++实现（2 观察者模式）
Ivan 的专栏
02-18 1051
最近在学习设计模式，用的是 《Head First 设计模式》这本书。感觉这本书写的还是很不错的，深入浅出的介绍了各种常用的设计模式。唯一有点不方便的地方是这本书的例子全都是用的 Java 来实现的。而我主要是用 C++。所以就动手将书上的代码用 C++ 来实现了一遍。观察者模式首先是三个接口的代码：//observer.h #ifndef OBSERVER_H #define OBSERVER_H
小白Head First设计模式(C++)入门
DRBlue
12-25 756
学习设计模式有很多好处，得啵得啵得…… blog文章权当我学习日记，免得以后找不到，高手请绕行，不要浪费时间。 以下是我今天用C++写的个Duck类，复现了书中用java写的duck类，大同小异： #include &lt;iostream&gt; using namespace std; //飞行行为类 class Flyable { public:     virtual void ...
C++设计模式--命令模式解析(head first 设计模式C++实现)
qq_42292775的博客
09-15 259
C++设计模式--命令模式解析(head first 设计模式C++实现)
C++设计模式--单例模式解析(head first 设计模式C++实现)
qq_42292775的博客
09-09 374
【代码】C++设计模式--单例模式解析(head first 设计模式C++实现)
Headfirst（四）工厂设计模式C++实现
10-21
在编程领域，设计模式是一种被广泛接受的解决常见问题的...通过C++实现这三种工厂模式，可以提高代码的可读性、可维护性和可扩展性。在实际开发中，合理选择和运用这些模式，能够帮助我们构建更加健壮和灵活的系统。
Head First 设计模式 （四） 工厂模式（factory pattern） C++实现
04-03
在C++实现中，可能涉及到模板、指针、智能指针等技术来实现工厂模式。例如，如果产品类有多种类型，可以使用模板方法让工厂能够创建任意类型的产品，或者使用`std::unique_ptr`或`std::shared_ptr`来管理对象生命...
Head First设计模式 C++代码实现
04-28
《Head First设计模式 C++代码实现》是一本深入浅出介绍设计模式的书籍，它将复杂的概念用易于理解的方式呈现，特别适合初学者和有一定经验的C++开发者。设计模式是软件开发中的一种最佳实践，它总结了在特定场景下...
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 1005
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 517
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 407
STL中的迭代器失效（vector为例）
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1215
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值