常用设计模式之抽象工厂模式

原创 2017年07月11日 17:57:00

抽象工厂模式:
抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。
应用场景:
当每个抽象产品都有多于一个的具体子类的时候,工厂角色怎么知道实例化哪一个子类呢?比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色,分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
每一个模式都是针对一定问题的解决方案,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式针对的是多个产品等级结构。
这里写图片描述
实现代码:

//Product.h
#ifndef PRODUCT_H
#define PRODUCT_H

class AbstractProductA
{
public:
    virtual ~AbstractProductA();
protected:
    AbstractProductA();
private:
};
class AbstractProductB
{
public:
    virtual ~AbstractProductB();
protected:
    AbstractProductB();
private:
};
class ProductA1:public AbstractProductA
{
public:
    ProductA1();
    ~ProductA1();
};
class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    ~ProductA2();
};
class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    ~ProductB1();
};
class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    ~ProductB2();
};

#endif // PRODUCT_H
//Product.cpp

#include"product.h"
#include<iostream>

using namespace std;

AbstractProductA::AbstractProductA()
{

}
AbstractProductA::~AbstractProductA()
{

}
AbstractProductB::AbstractProductB()
{

}
AbstractProductB::~AbstractProductB()
{

}
ProductA1::ProductA1()
{
    cout<<"ProductA1..."<<endl;
}
ProductA1::~ProductA1()
{

}
ProductA2::ProductA2()
{
    cout<<"ProductA2..."<<endl;
}
ProductA2::~ProductA2()
{

}
ProductB1::ProductB1()
{
    cout<<"ProductB1..."<<endl;
}
ProductB1::~ProductB1()
{

}
ProductB2::ProductB2()
{
    cout<<"ProductB2..."<<endl;
}
ProductB2::~ProductB2()
{

}
//AbstractFactory.h

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H
class AbstractProductA;
class AbstractProductB;

class AbstractFactory
{
public:
    virtual ~AbstractFactory();
    virtual AbstractProductA* CreateProductA()=0;
    virtual AbstractProductB* CreateProductB()=0;
protected:
    AbstractFactory();
};
class ConcreteFactory1:public AbstractFactory
{
public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
};
class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
};

#endif // ABSTRACTFACTORY_H
//AbstractFactory.cpp

#include"abstractfactory.h"
#include"product.h"
#include<iostream>

using namespace std;

AbstractFactory::AbstractFactory()
{

}
AbstractFactory::~AbstractFactory()
{

}
ConcreteFactory1::ConcreteFactory1()
{

}
ConcreteFactory1::~ConcreteFactory1()
{

}
AbstractProductA* ConcreteFactory1::CreateProductA()
{
    return new ProductA1();
}
AbstractProductB* ConcreteFactory1::CreateProductB()
{
    return new ProductB1();
}
ConcreteFactory2::ConcreteFactory2()
{

}
ConcreteFactory2::~ConcreteFactory2()
{

}
AbstractProductA* ConcreteFactory2::CreateProductA()
{
    return new ProductA2();
}
AbstractProductB* ConcreteFactory2::CreateProductB()
{
    return new ProductB2();
}

//Main.cpp

#include"abstractfactory.h"
#include<iostream>

using namespace std;

int main(int argc, char *argv[])
{
    AbstractFactory* cf1 = new ConcreteFactory1();

    cf1->CreateProductA();
    cf1->CreateProductB();

    AbstractFactory* cf2 = new ConcreteFactory2();

    cf2->CreateProductA();
    cf2->CreateProductB();

    system("pause");
    return 0;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

设计模式-抽象工厂模式

1.抽象工厂模式的定义及使用场景 抽象工厂也是创建型设计模式之一。为创建一组相关或者是相互依赖的对象提供一个接口,而不需要指定他们的具体类。一个对象族有相同约束时可以使用抽象工厂模式。 ...

[设计模式]-抽象工厂模式ing

定义:

设计模式 — 抽象工厂模式 (AbstractFactory)

本文将借助C++来介绍抽象工厂模式。
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)