Design-Pattern/abstractFactory.cpp at main · liliangnike/Design-Pattern · GitHub

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/*
    Factory method design pattern is used factory method to create different type products (chair, soft,...).

    Abstract factory design pattern is also user different factory methods to create concrete products (modernChair, classicChair, modernSofa, classicSofa), but the created types are

    abstract product types (chair, sofa,...).


*/
#include <iostream>
#include <string>

using namespace std;

class abstractProductA
{
public:
    virtual ~abstractProductA() {};

    virtual string funcA() const = 0;
};

class concreteProductA1 : public abstractProductA
{
public:
    string funcA() const override
    {
	return "Product A1";
    }
};

class concreteProductA2 : public abstractProductA
{
public:
    string funcA() const override
    {
	return "Product A2";
    }
};

class abstractProductB
{
public:
    virtual ~abstractProductB() {};

    virtual string funcB() const = 0;
    virtual string demoB(const abstractProductA &prodA) const = 0;
};

class concreteProductB1 : public abstractProductB
{
public:
    string funcB() const override
    {
	return "Product B1";
    }

    string demoB(const abstractProductA &prodA) const override
    {
	string str = prodA.funcA();
	return "Procduct B1 meets " + str + " in demo function.";
    }

};

class concreteProductB2 : public abstractProductB
{
public:
    string funcB() const override
    {
	return "Product B2";
    }

    string demoB(const abstractProductA &prodA) const override
    {
	string str = prodA.funcA();
	return "Procduct B2 meets " + str + " in demo function.";
    }
};

class abstractFactory
{
public:
    virtual abstractProductA * createProductA() const = 0;
    virtual abstractProductB * createProductB() const = 0;
};

class concreteFactory1 : public abstractFactory
{
public:
    abstractProductA * createProductA() const override
    {
	return new concreteProductA1();
    }

    abstractProductB * createProductB() const override
    {
	return new concreteProductB1();
    }

};

class concreteFactory2 : public abstractFactory
{
public:
    abstractProductA * createProductA() const override
    {
	return new concreteProductA2();
    }

    abstractProductB * createProductB() const override
    {
	return new concreteProductB2();
    }

};

void clientDemo(const abstractFactory *fact)
{
    abstractProductA *prodA = fact->createProductA();
    abstractProductB *prodB = fact->createProductB();

    cout << prodB->funcB() << endl;
    cout << prodB->demoB(*prodA) << endl;

    delete prodA;
    delete prodB;
};

int main()
{
    cout << "Run factory 1......" << endl;
    concreteFactory1 *factory1 = new concreteFactory1();
    clientDemo(factory1);
    delete factory1;
    cout << endl;


    cout << "Run factory 2......" << endl;
    concreteFactory2 *factory2 = new concreteFactory2();
    clientDemo(factory2);
    delete factory2;
    cout << endl;

    return 0;
}