Factory Method

Intent

Define an interface for creating an object, but let subclasses decide which class to
instantiate. Factory Method lets a class defer instantiation to subclasses.

#include 
#include 
#include 
#include 
#include 

class Document {
public:
	virtual void Open() {
		std::cout << "Document Open" << std::endl;
	}
	virtual void Close() {
	}
	virtual void Save() {
	}
	virtual void Revert() {
	}
};
class MyDocument : public Document {
public:
	virtual void Open() {
		std::cout << "MyDocument Open" << std::endl;
	}
	virtual void Close() {
	}
	virtual void Save() {
	}
	virtual void Revert() {
	}
};

class Application {
public:
	virtual std::shared_ptr<Document> CreateDocument() {
		return nullptr;
	}
	void NewDocument() {
		std::shared_ptr<Document> doc = CreateDocument();
		docs.push_back(doc);
		OpenDocument(doc);
	}
	void OpenDocument(std::shared_ptr<Document> doc) {
		doc->Open();
	}
private:
	std::vector<std::shared_ptr<Document> > docs{};
};

class MyApplication : public Application {
public:
	virtual std::shared_ptr<Document> CreateDocument() {
		std::cout << "MyApplication Construct" << std::endl;
		return std::make_shared<MyDocument>();
	}
};


int main()
{
	std::shared_ptr<Application> app = std::make_shared<MyApplication>();
	app->NewDocument();
}
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

Using templates to avoid subclassing

// DesignPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include 
#include 
#include 
#include 
#include 

class Product {
public:
	Product() {
	}
	virtual void callProductFunc() {
		std::cout << __FUNCTION__ << std::endl;
	}
};

class MyProduct1 : public Product {
public:
	MyProduct1() {
	}
	virtual void callProductFunc() {
		std::cout << __FUNCTION__ << std::endl;
	}
};

class MyProduct2 : public Product {
public:
	MyProduct2() {
	}
	virtual void callProductFunc() {
		std::cout << __FUNCTION__ << std::endl;
	}
};

class Creator {
public: 
	virtual std::shared_ptr<Product> CreateProduct() = 0;
};

// Using templates to avoid subclassing
template<class TheProduct>
class StandardCreator : public Creator {
public:
	virtual std::shared_ptr<Product> CreateProduct() {
		return std::make_shared<TheProduct>();
	}
};

class Application {
public:
	virtual void NewProduct() {
		
	}
protected:
	StandardCreator<MyProduct1> creator_1_;
	StandardCreator<MyProduct2> creator_2_;
};

class MyApplication : public Application {
public:
	virtual void NewProduct() {
		creator_1_.CreateProduct()->callProductFunc();
		creator_2_.CreateProduct()->callProductFunc();
	}
};

int main()
{
	std::shared_ptr<Application> app = std::make_shared<MyApplication>();
	app->NewProduct();
}
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