The factory mode is mainly used in C for the creation and use of decoupled objects. It introduces factory class to centrally manage the creation of objects, so that the client does not need to care about specific implementation details, and only needs to pass in parameters to obtain the required objects. Its core structure includes abstract products, specific products and factory categories. For example, in a drawing program, the corresponding graphic object can be generated by passing in "circle" or "square". In actual use, it is recommended: 1. Reduce memory allocation in combination with singletons or object pools; 2. Use smart pointers to manage resources; 3. Encapsulate type selection logic to support dynamic expansion; 4. Decide whether to introduce abstract factory classes based on needs. The factory model is suitable for scenarios where creation details need to be frequently expanded or hidden, but should be kept simple.

Using factory mode in C is mainly to solve the problem of decoupling of object creation and use. Simply put, it is to let a class hand over the responsibility of creating specific objects to another "factory" class to complete, which can improve the scalability and maintainability of the code.

The following scenarios and techniques can help you understand and apply the factory model more naturally.

What is the factory model?

Factory pattern is a creative design pattern . It defines a unified interface or base class, and a special "factory" class is responsible for creating specific object instances.
This is especially useful when you need to create different subclasses according to different conditions, such as loading different database connection classes based on configuration files, generating different types of parsers based on user input, etc.

Let's give a simple example:
You want to write a drawing program that supports drawing circles, squares and triangles. If each graphic is directly new, many changes will have to be made when adding new graphic in the later stage. When using the factory model, you only need to add a judgment to the factory to easily expand.

The basic structure of the factory model

Generally speaking, the factory model includes the following components:

• Abstract Product Class : Defines the public interface of the product.
• Concrete Product : Concrete Product that implements abstract products.
• Factory class : Provides a method to return different product instances according to parameters.

Let's give a basic example:

 class Shape {
public:
    virtual void draw() = 0;
};

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

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

class ShapeFactory {
public:
    Shape* createShape(const std::string& type) {
        if (type == "circle") return new Circle();
        if (type == "square") return new Square();
        return nullptr;
    }
};

In this way, the client only needs to know the string to get the corresponding graphic object, and does not need to care about how to create it.

Some optimization suggestions in actual use

1. Avoid new objects every time
   • It can combine singleton mode, object pool and other mechanisms to reduce frequent memory allocation.
2. Manage resources with smart pointers
   • After C 11, it is recommended to use std::unique_ptr or std::shared_ptr to prevent memory leakage.
3. Encapsulation type selection logic
   • Don’t write type judgments in the factory. You can dynamically add types through the registration mechanism.
4. Consider whether abstract factory classes are needed
   • If there is only one product family, an abstract factory may not be needed; but if there are multiple product series, an abstract factory is needed to unify the creation process.

For example, you can transform the above factory function like this:

 std::unique_ptr<Shape> createShape(const std::string& type) {
    if (type == "circle") return std::make_unique<Circle>();
    if (type == "square") return std::make_unique<Square>();
    return nullptr;
}

This is not only safer, but also easier to integrate into modern C projects.

When is the factory model suitable?

• When there are multiple similar classes in your system and they will change or expand frequently.
• When you want to hide object creation details and let the caller focus on usage rather than construction.
• When you want to create objects in a centralized manner, it is convenient for logging, exception handling, caching and other operations.

If you just use one or two categories temporarily, there is no need to force the design pattern to be applied, and it is more important to keep it simple.

Basically that's it. The factory model itself is not complicated, but if used well in actual projects, it can indeed make your code more organized and easier to maintain.

The above is the detailed content of Using the Factory Pattern in C. For more information, please follow other related articles on the PHP Chinese website!