工厂方法模式
讲道理就是最简单的纯虚函数继承模式，一个提供纯虚函数接口（假设叫process()）的类做Base Class，然后需要用到的类分别实现这个接口后，用一个工厂调BaseClass的这个方法就完事了
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
| class Base {
public:
Base() = default;
virtual void process() const = 0;
};
class Derived1 : public Base {
public:
virtual void process() const override {
std::cout << "Here is Derived1 process logic" << std::endl;
};
};
class Derived2 : public Base {
public:
virtual void process() const override {
std::cout << "Here is Derived2 process logic" << std::endl;
};
};
void call_derived(Base* ptr) {
ptr->process();
}
int main() {
Derived1 d1;
Derived2 d2;
call_derived(&d1);
call_derived(&d2);
return 0;
}
|
抽象工厂模式
总结就是用一个factory接口类包含要用到的接口类，这样就可以保证一次定制多个想用的类到一个特定的factory派生类里
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class Base1 {
public:
Base1() = default;
virtual process() const = 0;
}
class Base2 {
public:
Base2() = default;
virtual process() const = 0;
}
class Factory {
public:
Base1* createBase1() const = 0;
Base2* createBase2() const = 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
| class Base {
public:
Base() = default;
virtual process() const = 0;
}
class Derived1 : public Base {
public:
virtual void process() const override {
std::cout << "Here is Derived1 process logic" << std::endl;
};
};
class Derived2 : public Base {
public:
virtual void process() const override {
std::cout << "Here is Derived2 process logic" << std::endl;
};
};
class Generator {
public:
void add(const std::string &key, std::shared_ptr<Base> &val) {
content_.emplace(key, val);
};
private:
std::map<std::string, std::shared_ptr<Base>> content_;
}
int main() {
auto d1 = std::make_shared<Derived1>();
auto d2 = std::make_shared<Derived2>();
Generator g1;
g1.add("k1", d1);
Generator g2;
g2.add("k2", d2);
Generator g3;
g3.add("k1", d1);
g3.add("k2", d2);
}
|
感觉总结的不一定对，但八九不离十吧，这两天还真用到了生成器模式（应该是吧），以后多留意留意。
