The most commonly used design patterns in C include singleton mode, factory mode, observer mode, and policy mode. Singleton mode ensures that a class has only one instance and provides global access points, which is often used in scenarios such as configuration managers; factory mode encapsulates the object creation process, so that the caller does not need to know the specific class name, which is suitable for situations where the object creation logic is complex or changeable; observer mode implements a one-to-many dependency notification mechanism, which is widely used in UI updates or event listening systems; policy mode allows runtime switching algorithms or behaviors, and is suitable for scenarios such as payment systems that require dynamic changes in processing methods. These modes help developers build clearer and easier to maintain code structures by decoupling, hiding implementation details, and improving scalability.

The design pattern in C is actually not that mysterious. It is just some "routines" summarized in actual development to solve common code structure problems. If you have written medium and large projects, you will find that these patterns can help you organize your code more clearly and easily maintain.

The following design patterns are most commonly used and are particularly practical for C developers:

Singleton Pattern

The purpose of this pattern is to ensure that a class has only one instance and provide a global access point. For example, if you have a configuration manager in your project, you definitely don't want multiple instances to exist at the same time, which will cause data confusion.

Key points of implementation:

• Set the constructor to private
• Provide static method to obtain instances
• Usually use lazy loading to create objects

 class ConfigManager {
private:
    static ConfigManager* instance;
    ConfigManager() {}

public:
    static ConfigManager* getInstance() {
        if (!instance) {
            instance = new ConfigManager();
        }
        return instance;
    }
};

Note: Thread safety is a place where problems are prone to problems. In multi-threaded environments, locking or local static variables are required (supported after C 11).

Factory Pattern

Factory pattern is used to decouple object creation and use. Simply put, it is to encapsulate the new process. The caller does not need to know the specific class name, but just needs to tell the factory what type I want.

Applicable scenarios:

• Object creation logic is complex
• Different subclasses need to be returned according to different conditions
• Want to hide specific implementation classes

For example, you may have a shape factory that returns objects such as circles, squares, etc. according to the input parameters:

 enum ShapeType { CIRCLE, SQUARE };

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

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

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

class ShapeFactory {
public:
    Shape* createShape(ShapeType type) {
        switch (type) {
            case CIRCLE: return new Circle();
            case SQUARE: return new Square();
            default: return nullptr;
        }
    }
};

In this way, the client does not need to directly new specific classes, and it is also convenient to change the implementation.

Observer Pattern

Observer mode is used for one-to-many dependency notification mechanisms. For example, UI updates and event listening systems, this pattern is very common.

Core idea:

• Maintain a list of observers by observers
• Notify all observers when the state changes
• Observers handle updates separately

For example, you wrote a weather monitoring system, the sensor is the observer, and the UI is the observer. Once the sensor value changes, all UIs are notified to refresh.

The implementation is usually to define the interface, the observer registers to the topic, and then the topic triggers the update method when appropriate.

Strategy Pattern

The policy pattern allows you to change algorithms or behaviors at runtime. Suitable for scenarios where processing methods need to be switched according to different situations.

For example, in the payment system, you can have different payment strategies such as Alipay, WeChat, UnionPay, etc., and call them uniformly through one interface.

advantage:

• Replace the algorithm without modifying the original code
• Avoid a lot of if-else or switch-case
• Strong scalability

You can define an abstract policy class, each specific policy implements the corresponding method, and then the context class holds the policy interface pointer and is dynamically bound when called.

Basically, there are only these most commonly used C design patterns. Each has its own applicable scenario, the key is to understand what problems they solve. Don't memorize it by rote. If you use it too much, you will naturally know when to use it.

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