2311C++抽象工厂

1,为啥需要工厂设计模式?工厂设计模式可解决什么问题?

先看一下示例,多态示例.

#include 
using namespace std;
class Shape {
public:
    Shape() { }
    virtual void drawShape()
    {
        cout << "base draw shape" << endl;
    }
};
class Rectangular : public Shape {
public:
    Rectangular(){ }
    void drawShape ()
    {
        cout << "draw rectangular" << endl;
    }
};
class Triangular : public Shape {
public:
    Triangular () { }
    void drawShape ()
    {
        cout << "draw triangular" << endl;
    }
};
class Circle : public Shape {
public:
    Circle(){ }
    void drawShape ()
    {
        cout << "draw circle" << endl;
    }
};
int main()
{
    Shape *rect = new Rectangular();
    rect->drawShape();
    delete rect;
    Shape *tri = new Triangular();
    tri->drawShape();
    delete tri;
    Shape *cir = new Circle();
    cir->drawShape();
    delete cir;
    /*这里添加许多形状...*/
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

上述代码示例很简单,想带多态,绘画矩形,三角形,圆等.思考一个问题:如果还要画菱形,椭圆等等.很容易出现N多子类继承基本Shape,main()中的会大量的new XXXX,导致很难维护和扩展代码.

这就是工厂对象设计模式解决的问题之一.

还有,基类并不知道具体要实例化哪一个具体的子类,具体实例化要延迟到继承类中.

2,工厂设计模式

工厂创建产品. 产品==>多子产品.
1

工厂设计模式结构图,该模式下,工厂基类知道如何实例化具体产品

工厂=>具体工厂(创建产品)方法
产品(操作)=>具体产品(操作).
1
2

工厂设计模式结构图,延迟到子类中具体实例化对象方法

基本要素:
(1)抽象产品Product;
(2)具体产品ConcreteProduct;
(3)抽象工厂Factory.
(4)具体的工厂ConcreteFactory

下面直接给出代码示例:
头文件

#include 
using namespace std;
class Computer {
public:
    Computer();
    virtual ~Computer() = 0;
private:
};
class DellComputer: public Computer {
public:
    ~DellComputer();
    DellComputer();
private:
};
class AppleComputer : public Computer {
public:
    AppleComputer();
    ~AppleComputer();
};
class Factory {
public:
    Factory();
    virtual ~Factory() = 0;
    virtual Computer *CreateComputer(const string &type) = 0;//
private:
//串类型;
};
class ConcreateFactory: public Factory {
public:
    ~ConcreateFactory();
    ConcreateFactory();
    Computer *CreateComputer(const string &type);
};

//main.cpp
#include "product.h"
#include 
using namespace std;
Computer::Computer()
{
    cout << "Computer()" << endl;
}
Computer::~Computer()
{
    cout << "~Computer()" << endl;
}
DellComputer::DellComputer()
{
    cout << "DellComputer()" << endl;
}
DellComputer::~DellComputer()
{
    cout << "~DellComputer()" << endl;
}
AppleComputer::AppleComputer()
{
    cout << "AppleComputer()" << endl;
}
AppleComputer::~AppleComputer()
{
    cout << "~AppleComputer()" << endl;
}
Factory::Factory()
{
    cout << "Factory()" << endl;
}
Factory::~Factory()
{
    cout << "~Factory()" << endl;
}
ConcreateFactory::ConcreateFactory()
{
    cout << "ConcreateFactory()" << endl;
}
ConcreateFactory::~ConcreateFactory()
{
    cout << "~ConcreateFactory()" << endl;
}
Computer *ConcreateFactory::CreateComputer(const string &type)
{
    if (type == "dell")
        return new DellComputer();
    else if (type == "apple")
        return new AppleComputer();
    else
        throw invalid_argument("Invalid argument");
}
int main()
{
    Factory *fac = new ConcreateFactory();
    Computer *dell = fac->CreateComputer("dell"); //制造`dell`电脑
    delete dell;
    Computer *apple = fac->CreateComputer("apple"); //制造苹果电脑
    delete apple;
    delete fac;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

使用工厂类的好处是,可在工厂类中封装创建对象的逻辑,使代码更模块化和清晰.同时,工厂类可按需选择创建不同产品对象,客户代码只需与抽象产品类交互,而不需要了解具体产品类.

这样代码更灵活,且更容易扩展和修改.

3,抽象工厂设计模式

工厂模式仅局限于某一个类,有时候需要为一组相关或依赖的对象提供配套的接口.此时就需要抽象工厂模式了,其实抽象工厂模式跟工厂模式是一回事.

抽象工厂(创建A,创建B)
=>多个具体工厂(创建A,创建B)
抽象产品A=>具体A1,具体A2
抽象产品B=>具体B1,具体B2
1
2
3
4

抽象工厂设计模式结构图,抽象工厂设计模式就是工厂模式的扩展版.

假如要为生成的电脑装操作系统,假如Dell--->windows系统,Apple----->IOS系统,再来一个华为电脑,需要装鸿蒙系统等.
头文件

#include 
using namespace std;
class Computer {
public:
    Computer();
    virtual ~Computer() = 0;
private:
};
class DellComputer: public Computer {
public:
    ~DellComputer();
    DellComputer();
private:
};
class OS {
public:
    OS();
    virtual ~OS() = 0;
};
class WindowsOS : public OS {
public:
    WindowsOS();
    ~WindowsOS();
};
class Factory {
public:
    Factory();
    virtual ~Factory() = 0;
    virtual Computer *CreateComputer() = 0;
    virtual OS *CreateOS() = 0;
private:
//串类型;
};
class ConcreateFactory: public Factory {
public:
    ~ConcreateFactory();
    ConcreateFactory();
    Computer *CreateComputer();
    OS *CreateOS();
};
//main.cpp
#include "product.h"
#include 
using namespace std;
Computer::Computer()
{
    cout << "Computer()" << endl;
}
Computer::~Computer()
{
    cout << "~Computer()" << endl;
}
DellComputer::DellComputer()
{
    cout << "DellComputer()" << endl;
}
DellComputer::~DellComputer()
{
    cout << "~DellComputer()" << endl;
}
OS::OS()
{
    cout << "OS()" << endl;
}
OS::~OS()
{
    cout << "~OS()" << endl;
}
WindowsOS::WindowsOS()
{
    cout << "WindowsOS()" << endl;
}
WindowsOS::~WindowsOS()
{
    cout << "~WindowsOS()" << endl;
}
Factory::Factory()
{
    cout << "Factory()" << endl;
}
Factory::~Factory()
{
    cout << "~Factory()" << endl;
}
ConcreateFactory::ConcreateFactory()
{
    cout << "ConcreateFactory()" << endl;
}
ConcreateFactory::~ConcreateFactory()
{
    cout << "~ConcreateFactory()" << endl;
}
Computer *ConcreateFactory::CreateComputer()
{
    return new DellComputer();
}
OS *ConcreateFactory::CreateOS()
{
    return new WindowsOS();
}
int main()
{
    Factory *fac = new ConcreateFactory();
    Computer *dell = fac->CreateComputer();
    OS *os = fac->CreateOS();
    delete dell;
    delete os;
    delete fac;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110