设计模式：工厂模式(Factory Method)---将实例的生成交给子类

最新推荐文章于 2022-10-26 21:02:52 发布

OceanStar的学习笔记

最新推荐文章于 2022-10-26 21:02:52 发布

阅读量183

点赞数

分类专栏： C++

原文链接：https://gitee.com/zsxxsz/DesignPattern

版权

C++ 专栏收录该内容

1060 篇文章 297 订阅

订阅专栏

本文详细介绍了工厂模式在软件设计中的作用，包括模板方法模式的结合使用。通过身份证制造和产品创建的实例，展示了如何定义产品接口并由子类实现具体功能。同时，阐述了抽象工厂模式的概念，强调了创建一系列相关对象而不直接指定类的能力。文章以代码示例为支撑，演示了如何在实际编程中运用工厂模式和抽象工厂模式。

摘要由CSDN通过智能技术生成

工厂模式

在Template Method模式中，我们在父类中规定处理的流程，在子类中实现具体的处理
工厂模式：提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类

实现

实例1：制造身份证

Product类和Factory类，组成了生成实例的框架
IDCard类和IDcardFactory类负责实际的加工处理

Product类

Product是用来表示产品的类，在该类中仅声明了use抽象方法。use方法的实现被交给了Product的子类负责

在这个框架中，定义了产品是“任意的可以use的”东西

class Product {
public:
    virtual ~Product() { }
    virtual void use() = 0;
};

Factory类

Factory类里，使用了template method模式。
该类还声明了用于“声明产品”的CreateProduct抽象方法和用于“注册产品”的registerProduct抽象方法。
“生成产品”和“注册产品”的具体处理则交给了Factory类的子类负责。

class Factory {
public:
    Product * create(const std::string& owner)  {
        Product *p = CreateProduct(owner);
        registerProduct(p);
        return p;
    }


    virtual ~Factory() = default;

    virtual Product* CreateProduct(const std::string& owner) = 0;

protected:
    Factory() = default;

    virtual void registerProduct(Product *product) = 0 ;
};

IDCard类

上面的两个类定义了框架，接下来我们把关注点转移到负责加工处理的这一边。

IDCard实现了“实际产品”是什么样，必须实现use方法

class IDCard :public Product {
private:
    std::string owner_;
public:
    explicit IDCard(const std::string& owner) : owner_(owner){
        std::cout << "create [" << owner << "]'s card" << std::endl;
    }
    void use() {
        std::cout << "use  [" << owner_ << "]'s card" << std::endl;
    }

    const char *getOwner(){
        return owner_.c_str();
    }
    ~IDCard() override = default;
};

IDCardFactory类

class IDCardFactory :public Factory {
private:
    std::list<std::string> owners;
public:
    IDCardFactory() {
        std::cout << "IDCardFactory..." << std::endl;
    }

    ~IDCardFactory() {

    }

private:
    Product* CreateProduct(const std::string& owner) {
        return new IDCard(owner);
    }

    void registerProduct(Product *product){
        IDCard *idCard = (IDCard*)product;
        owners.emplace_back(idCard->getOwner());
    }
};

测试

int main() {
    Factory *factory = new IDCardFactory();
    Product *product = factory->CreateProduct("aaa");
    product->use();

    Product *product1 = factory->CreateProduct("bbb");
    product1->use();


    delete factory;
    delete product;
    delete product1;
    return 0;
}

实现2：

#include <iostream>

// Product

class Product {
public:
    virtual ~Product() { }
    virtual void say() = 0;
};

class ConcreteProduct :public Product {
public:
    ConcreteProduct() {
        std::cout << "ConcreteProduct..." << std::endl;
    }
    void say() {
        std::cout << "ConcreteProduct Say..." << std::endl;
    }
    ~ConcreteProduct() { }
};

// Factory

class Factory {
public:
    virtual Product* CreateProduct() = 0;
    virtual ~Factory() { }
protected:
    Factory() { }
};

class ConcreteFactory :public Factory {
public:
    ConcreteFactory() {
        std::cout << "ConcreteFactory..." << std::endl;
    }

    ~ConcreteFactory() {

    }

    Product* CreateProduct() {
        return new ConcreteProduct();
    }

};

// Test

int main() {
    Factory *factory = new ConcreteFactory();
    Product *product = factory->CreateProduct();
    product->say();

    delete factory;
    delete product;

    return 0;
}

实现

#include <iostream>
#include <string>
using namespace std;
/*
抽象工厂模式：
提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类
*/
class AbstractProduct
{
public:
	AbstractProduct() {}
	virtual ~AbstractProduct() {}
 
	virtual void Func() = 0;
};
 
class ProductA_1 :public AbstractProduct
{
public:
	ProductA_1() {}
	~ProductA_1() {}
 
	virtual void Func() override
	{
		cout << "ProductA_1 Func" << endl;
	}
 
};
class ProductB_1 :public AbstractProduct
{
public:
	ProductB_1() {}
	~ProductB_1() {}
 
	virtual void Func() override
	{
		cout << "ProductB_1 Func" << endl;
	}
 
};
class ProductA_2 :public AbstractProduct
{
public:
	ProductA_2() {}
	~ProductA_2() {}
 
	virtual void Func() override
	{
		cout << "ProductA_2 Func" << endl;
	}
 
};
class ProductB_2 :public AbstractProduct
{
public:
	ProductB_2() {}
	~ProductB_2() {}
 
	virtual void Func() override
	{
		cout << "ProductB_2 Func" << endl;
	}
 
};
class AbstractFactory
{
public:
	AbstractFactory() {}
	virtual ~AbstractFactory() {}
	virtual AbstractProduct* CreatProduct1() = 0;
	virtual AbstractProduct* CreatProduct2() = 0;
};
class FactoryA : public AbstractFactory
{
public:
	FactoryA() {}
	~FactoryA() {}
 
	virtual AbstractProduct * CreatProduct1() override
	{
		return new ProductA_1;
	}
	virtual AbstractProduct * CreatProduct2() override
	{
		return new ProductA_2;
	}
 
};
class FactoryB : public AbstractFactory
{
public:
	FactoryB() {}
	~FactoryB() {}
 
	virtual AbstractProduct * CreatProduct1() override
	{
		return new ProductB_1;
	}
	virtual AbstractProduct * CreatProduct2() override
	{
		return new ProductB_2;
	}
 
};
 
int main()
{
	//AbstractFactory *f = new FactoryA;
	AbstractFactory *f = new FactoryB;
 
	AbstractProduct *p1 = f->CreatProduct1();
	AbstractProduct *p2 = f->CreatProduct2();
 
	p1->Func();
	p2->Func();
 
	delete f;
	delete p1;
	delete p2;
 
	getchar();
	return 0;
}

总结

登场

在工厂模式下有如下角色。通过查看工厂模式的类图，我们可以知道。父类(框架)这一方的Creator角色和Product角色的关系和子类(具体加工)这一方的ConcreteCreator角色和ConcreteProduct角色的关系是平行的。

在这里插入图片描述

Product(产品)：
- 属于框架这一方，是一个抽象类
- 它定义了工厂模式中生成的那些实例所持有的接口(API)，但具体的处理则由子类ConcreteProduct角色决定。(Product)
Creator(创建者)
- 属于框架这一方，它负责生成Product角色的抽象类，但具体的处理则由子类ConcreteCreator角色决定。（Factory）
- Creator角色对于实际负责生成实例的ConcreteCreator角色一无所知，它唯一知道的是，只要调用Product角色和生成实例的方法CreateProduct，就可以生成具体产品的实例。这里没有用new关键字而是调用生成实例的专用方法CreateProduct来生成实例，这样就可以防止父类和其他具体类耦合。
ConcreteProduct（具体的产品）
- ConcreteProduct角色属于具体加工的这一方，决定了具体的产品
ConcreteCreator（具体的创建者）：
- ConcreteCreator角色属于具体加工的这一方，负责生成具体的产品