Abstract_Factory

#include <iostream>

using namespace std;

#define DESTORY_POINTER(ptr) if (ptr) { delete ptr; ptr = NULL; }

class ProductFamilyA
{
public:
    virtual ~ProductFamilyA() {}
    virtual void Action()=0;

protected:
    ProductFamilyA() {}
};

class ProductFamilyB
{
public:
    virtual ~ProductFamilyB() {}
    virtual void Action()=0;

protected:
    ProductFamilyB() {}
};

class Factory
{
public:
    virtual ~Factory() {}
    virtual ProductFamilyA* CreateProductA()=0;
    virtual ProductFamilyB* CreateProductB()=0;

protected:
    Factory() {}
};

class ProductA1 : public ProductFamilyA
{
public:
    ProductA1() {}
    void Action() { cout<<"ProductFamilyA->ProductA1::Action"<<endl; }
};

class ProductA2 : public ProductFamilyA
{
public:
    ProductA2() {}
    void Action() { cout<<"ProductFamilyA->ProductA2::Action"<<endl; }
};

class ProductB1 : public ProductFamilyB
{
public:
    ProductB1() {}
    void Action() { cout<<"ProductFamilyB->ProductB1::Action"<<endl; }
};

class ProductB2 : public ProductFamilyB
{
public:
    ProductB2() {}
    void Action() { cout<<"ProductFamilyB->ProductB2::Action"<<endl; }
};

class Factory1 : public Factory
{
public:
    ProductFamilyA* CreateProductA() { return new ProductA1; }
    ProductFamilyB* CreateProductB() { return new ProductB1; }
};

class Factory2 : public Factory
{
public:
    ProductFamilyA* CreateProductA() { return new ProductA2; }
    ProductFamilyB* CreateProductB() { return new ProductB2; }
};

int main(int argc, char *argv[])
{
    Factory* pFactory = NULL;
    ProductFamilyA* pProductFamilyA = NULL;
    ProductFamilyB* pProductFamilyB = NULL;

    pFactory = new Factory1;

    pProductFamilyA = pFactory->CreateProductA();
    pProductFamilyB = pFactory->CreateProductB();

    pProductFamilyA->Action();
    pProductFamilyB->Action();

    DESTORY_POINTER(pFactory);
    DESTORY_POINTER(pProductFamilyA);
    DESTORY_POINTER(pProductFamilyB);

    pFactory = new Factory2;
    pProductFamilyA = pFactory->CreateProductA();
    pProductFamilyB = pFactory->CreateProductB();

    pProductFamilyA->Action();
    pProductFamilyB->Action();

    DESTORY_POINTER(pFactory);
    DESTORY_POINTER(pProductFamilyA);
    DESTORY_POINTER(pProductFamilyB);

    return 0;
}
时间: 2024-11-13 09:00:35

Abstract_Factory的相关文章

设计模式——抽象工厂模式(C++实现)

1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 7 class STAbstractProductA 8 { 9 public: 10 virtual void use() = 0; 11 }; 12 13 class STProductA1: public STAbstractProductA 14 { 15 public: 16 virtual void use() 17 { 18 c

设计模式(5)---抽象工厂模式

抽象工厂模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖.但是随着新的类型增加时,必须对原有的简单工厂进行修改,破坏了开放-封闭原则. 抽象工厂模式实现时,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,抽象工厂把简单工厂的内部逻辑判断移到了客户端来进行.你想要加功能,本来是改工厂

Abstract Factory 抽象工厂模式

提供一个创建一些列相关或相互依赖对象的接口,而无需指定它们具体的类. 抽象工厂顾名思义就是对工厂的抽象,它提供了一组创建抽象产品对象的操作接口,我们实际使用的是抽象工厂的派生类,派生类中提供了操作的具体实现,创建一组具体的对象. 以下情况可以使用抽象工厂模式: 一个系统要独立于它的产品的创建.组合和表示时. 一个系统要由多个产品系列中的一个来配置时. 当你要强调一系列相关的产品对象的设计以便进行联合使用时. 当你提供一个产品类库,而只想显示它们的接口而不是实现时. 抽象工厂模式的优缺点: 他分离

erlang与设计模式(二)——工厂、抽象工厂、建造者

Russell-X-Shanso 工厂模式.抽象工厂模式.建造者模式,均为创建类模式,其共有的设计思路主要在于根据情况理清并封装创建流程(创建进程.创建gen_server.组建record或maps等复合数据结构等).解耦.定向扩展等等. (注:由于这三个创建类模型解决的问题近似,面向对象语言中的解决方式也较为近似,因此我们放在一起来讨论:) 3.工厂模式( Factory Method ) (1)意图:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类

[Android基础系列]设计模式(一)

前言 这篇文章可以说是java基础的范畴,为了下一篇Android开发中的常用设计模式做一下铺垫,也顺便反思一下. 正文 设计模式分类 分类方式是多样的,这里我们按照功能类型进行分类: 创建型 工厂方法 Factory Method 抽象工厂 Abstract Factory 建造者 Builder 原型 Prototype 单例 Singleton 结构型 适配器 Adapter Class/Object 桥接 Bridge 组合 Composite 装饰 Decorator 外观 Facad

23种设计模式概要及易懂的例子

23种设计模式(分为三大类) 因为内容是从有道云笔记挪过来的,所以排版有点丑,如有不足或错误还望指点.. 注意,一些设计模式之间的(代码)"形式"虽然相同或相似,但是"语义"是截然不同的.个人认为设计模式提倡的是一种编码思想,而不是规范. 为什么要使用设计模式?为了代码复用,增加可维护性 设计模式的六大原则 1.开闭原则(Open Close Principle) 开闭原则的意思是:对扩展开放,对修改关闭.在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插

Java设计模式之简单工厂、工厂方法和抽象工厂

在前面的学习中(参见前面的博客),我们学到了很多OO原则: 封装变化 多用组合,少用继承 针对接口/超类编程,不针对实现编程 松耦合 开闭原则 让我们从一个简单的类开始,看看如何将之改造成符合OO原则的类以及工厂模式在解耦中的威力. class FoodStore { public Food orderFood() //通过此方法顾客从食物商店中得到食物 { Food food=new Food(); food.prepare(); // 准备食物 food.cut(); // 将食物切好 fo

(转自精通Python设计模式)Python设计模式之创建型模式——1.工厂模式

在工厂设计模式中,客户端可以请求一个对象,而无需知道这个对象来自哪里:也就是,使用哪个类类生成这个对象.工厂背后的思想是简化对象的创建.与客户端自己基于类实例化直接创建对象相比,基于一个中心化函数来实现,更易于追踪创建了哪些对象.通过将创建对象的代码和使用对象的代码解耦,工厂能够降低应用维护的复杂度. 工厂通常有两种形式:一种是工厂方法,它是一个方法(或是一个函数),对不同的输入参数返回不同的对象:第二种是抽象工厂,它是一组创建一系列相关事物对象的工厂方法. 1. 工厂方法 在工厂方法模式中,我