Factory mode is a creative design mode used to uniformly manage the creation of objects. It hides the instantiation details of specific classes through factory classes to improve scalability and maintenance; its core structure includes abstract product classes, specific product classes and factory classes; for example, in C, you can inherit the Shape base class and return the Circle or Rectangle instance according to parameters by ShapeFactory; use factory mode to decouple object creation and use, facilitate expansion and unified management creation logic; practical applications such as ParserFactory can create corresponding parsers based on file format; it is recommended to use smart pointers to handle error types during implementation, and consider using the automatic registration mechanism of mapping tables to optimize multi-type management.

Factory mode is a very practical design mode in C, especially suitable for scenarios where different objects need to be created dynamically based on parameters. It is responsible for the creation of objects through a factory class, hiding the instantiation details of concrete classes, and improving the scalability and maintainability of the code.

What is the factory model?

Factory Pattern is a creative design pattern that provides a unified way to create objects without exposing specific implementation classes. The advantage of this is that when the requirements change, you only need to modify the factory parts without affecting the code using these objects.

For example, you have a program that needs to create different shapes (shapes) according to different inputs, such as circles (Circle), rectangles (Rectangle), etc. At this time, you can use factory mode to centrally manage these creation logic.

The basic structure of the factory model

To implement the factory model, the following components are usually required:

• Abstract product class : defines the interface or base class of the product.
• Specific product category : Inherited from abstract product category to realize specific functions.
• Factory class : Contains methods used to create products, returning different product instances according to input parameters.

Here is a simple example:

 #include <iostream>
#include <memory>
using namespace std;

// Abstract product class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

// Specific product class Circle: public Shape {
public:
    void draw() override {
        cout << "Draw Circle" << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Draw Rectangle" << endl;
    }
};

// Factory class ShapeFactory {
public:
    unique_ptr<Shape> createShape(const string& type) {
        if (type == "circle") {
            return make_unique<Circle>();
        } else if (type == "rectangle") {
            return make_unique<Rectangle>();
        }
        return nullptr;
    }
};

In this way, the caller only needs to know the incoming string "circle" or "rectangle" to get the corresponding graphic object.

Benefits of using factory model

• Decoupled object creation and use : The user does not need to care about how the object is created, but only needs to tell the factory what type I want.
• Easy to expand : If you want to add a Triangle type in the future, you only need to add a new class and modify the factory method, and you don't need to move other code.
• Unified portal : All creation logic is centralized in the factory for easy management and debugging.

Let's give an example in actual development:
You are making a drawing software that supports importing multiple graphics formats (such as SVG, PNG, PDF). You can define a parser class for each format and then create the corresponding parser through a ParserFactory. In this way, when adding new file formats in the future, you only need to add judgment logic to the factory.

Things to note when implementing

• It is recommended to use smart pointers for return types : For example, unique_ptr is used in the above example to avoid memory leakage.

• Error handling mechanism : If the type passed in is not supported, there should be a clear prompt or a null pointer should be returned by default.

• Is the factory method static?

  If you do not plan to save the factory's state, you can make createShape a static method, which makes it more convenient to call:

   static unique_ptr<Shape> createShape(const string& type);

• Consider using mapping tables to automatically register (advanced): If you have many products, you can use map> to automatically register to create functions to avoid a bunch of if-else.

---

Basically that's it. The factory model looks simple, but it is very practical in actual projects, especially when building large systems, which can effectively reduce the coupling between modules.

The above is the detailed content of C factory pattern example. For more information, please follow other related articles on the PHP Chinese website!