C++ 设计模式：工厂模式

工厂模式是一种创建型设计模式，通过封装对象的创建过程，提高代码的可维护性、可扩展性，并实现对象的创建与使用的解耦。

简单工厂模式： 提供一个工厂类，根据传入的参数来决定创建哪种产品类的实例。这种模式不符合开闭原则，因为每次添加新产品类型都需要修改工厂类。

class products {
public:
    int money = 0;
    virtual void sell() = 0;
};
class apple :public products {
public:
    void sell() {
        money += 10;
    }
};
class banana :public products {
public:
    void sell() {
        money += 20;
    }
};
class factory {
public:
    static products* get_product(int d) {
        switch (d) {
        case 0:return new apple;
        case 1:return new banana;
        }
        return nullptr;
    }
};
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

工厂方法模式：定义一个创建产品的接口，由子类决定实例化哪个产品类。每个具体工厂类对应一个具体产品类，符合开闭原则，但客户端需要知道具体工厂类。

class products {
public:
    virtual void sell() = 0;
};

class factory {
public:
    virtual products* get_product() = 0;
};

class apple :public products{
public:
    void sell(){
        std::cout << "apple" << std::endl;
    }
};

class banana :public products {
public:
    void sell() {
        std::cout << "banana" << std::endl;
    }
};

class apple_producter:public factory  {
public:
    products* get_product() {
        return new apple;
    }
};

class banana_producter:public factory {
public:
    products* get_product() {
        return new banana;
    }
};
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

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式通过工厂接口创建一族产品，有多个具体工厂类对应不同的产品族，符合开闭原则且客户端无需知道具体工厂和产品类。

class products {
public:
    virtual void show() = 0;
};
//抽象产品族
class fruit :public products {};

class apple :public fruit {
public:
    void show() {
        std::cout << "apple" << std::endl;
    }
};

class banana :public fruit {
public:
    void show() {
        std::cout << "banana" << std::endl;
    }
};
//抽象产品族
class vegetable :public products {};

class potato :public vegetable {
public:
    void show() {
        std::cout << "potato" << std::endl;
    }
};

class tomato :public vegetable {
public:
    void show() {
        std::cout << "tomato" << std::endl;
    }
};

class factory {
public:
    virtual fruit* get_fruit() = 0;
    virtual vegetable* get_vegetable() = 0;
};

class farm1:public factory {
public:
    fruit* get_fruit() {
        return new apple;
    }
    vegetable* get_vegetable() {
        return new potato;
    }
};

class farm2:public factory {
public:
    fruit* get_fruit() {
        return new banana;
    }
    vegetable* get_vegetable() {
        return new tomato;
    }
};
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

工厂模式的优点

• 封装和隐藏实现细节： 工厂模式将对象的创建过程封装在一个独立的类或方法中，使得客户端代码无需了解对象的具体实现细节。这种封装提高了代码的抽象性，隐藏了实现细节，使系统更加模块化，降低了耦合度。

• 易于扩展： 工厂模式使得系统更容易扩展，当需要添加新的对象类型时，只需修改工厂类或方法而不需要修改客户端代码。这有利于遵循开闭原则，即对扩展开放，对修改关闭。

• 单一职责原则： 工厂模式有助于遵循单一职责原则，即一个类应该只有一个原因引起变化。工厂负责对象的创建，客户端负责对象的使用，这样各自的职责清晰明确，使得代码更易于理解和维护。

• 代码复用： 工厂模式促进了代码的重用。对象的创建逻辑被集中在一个地方，可以在多个地方共享相同的创建逻辑，避免了重复的代码。

• 依赖注入： 工厂模式使得依赖注入更容易实现。通过将对象的创建交给工厂，可以更方便地在需要时注入不同实现的对象，而无需直接修改客户端代码。

• 抽象层的引入： 工厂模式引入了一个抽象层，客户端通过这个抽象层与具体的对象实现解耦。这种解耦提高了代码的灵活性，使得客户端更容易适应变化。