The SOLID principle is five core principles used in object-oriented programming to improve the maintainability and extensibility of software design. ① The single responsibility principle (SRP) requires a class to be responsible for only one task to avoid multifunctional coupling; ② The opening and closing principle (OCP) emphasizes opening and closing of extensions and closing modifications, and implementing behavior expansion through inheritance and polymorphism; ③ The Richter replacement principle (LSP) ensures that subclasses can transparently replace parent classes without changing program accuracy; ④ The interface isolation principle (ISP) advocates defining fine-grained interfaces to avoid unnecessary dependencies; ⑤ The dependency inversion principle (DIP) advocates relying on abstraction rather than concrete implementation, reducing the coupling between modules. These principles can be effectively implemented in C through abstract classes, interface design, dependency injection, etc.

SOLID principles are a set of five design principles intended to make software designs more understandable, flexible, and maintainable. These principles were introduced by Robert C. Martin (Uncle Bob) and are widely used in object-oriented programming, including C . Understanding and applying these principles can help you write better, cleaner, and more scalable C code.

Single Responsibility Principle (SRP)

This principle states that a class should have only one reason to change , meaning it should have only one job or responsibility.

In practice, this means you shouldn't cram multiple functions into a single class. For example, if you have a class that reads data from a file, processes it, and logs the result, it's violating SRP. Each of those tasks could be split into separate classes.

How to apply it in C:

• Split large classes into smaller ones with focused responsibility.
• Use helper classes for things like logging, serialization, or input/output.

Example: instead of having a ReportGenerator that also writes files, create a FileWriter class to handle saving files separately.

Open/Closed Principle (OCP)

The idea here is that software entities (classes, functions, modules) should be open for extension but closed for modification .

This means that instead of changing existing code every time you need something new, you should structure your code so that you can add behavior without modifying existing logic.

How to do this in C:

• Use inheritance and polymorphism to allow extension.
• Define interfaces or abstract base classes for common operations.

Example: If you have a shape-drawing system, instead of adding a new condition for each shape type, define a Shape base class with a virtual draw() method. Then derive Circle , Square , etc., from it.

Liskov Substitution Principle (LSP)

This principle says that objects of a superclass should be replaced with objects of a subclass without breaking the application .

In simpler terms, derived classes should behave correctly when used in place of their base class.

What to watch out for in C:

• Avoid overriding methods in a way that changes expected behavior.
• Don't throw unexpected exceptions in derived classes.
• Be careful with preconditions/postconditions — they shouldn't get stricter in subclasses.

Example: If you have a Rectangle class with setWidth() and setHeight() , creating a Square class that inherits from it and overrides both setters to keep width and height equal might violate LSP, because using Square where Rectangle is expected could produce incorrect results.

Interface Segregation Principle (ISP)

This one suggests that clients should not be forced to depend on interfaces they don't use .

Instead of having one large interface with many methods, it's better to break it into smaller, more specific interfaces.

Applying ISP in C:

• Create small, focused abstract classes (interfaces).
• Let classes inherit only what they actually need.

Example: If you're building a game with different types of players (like human and AI), don't put all possible actions in one interface. Instead, split into IPlayer , IAIController , etc., depending on what each type needs.

Dependency Inversion Principle (DIP)

This principle has two parts:

1. High-level modules should not depend on low-level modules. Both should depend on abstractions.
2. Abstractions should not depend on details. Details should depend on abstractions.

It's about reducing tight coupling between components.

How to implement DIP in C:

• Program against interfaces or abstract classes.
• Use dependency injection to pass dependencies rather than hard-coding them.

Example: instead of having a DatabaseLogger directly inside a service class, pass an interface like ILogger into the constructor. That way, you can switch logging implementations easily.

So while C doesn't enforce SOLID principles directly, following them leads to better architecture and easier maintenance. It's not always straightforward, especially in complex systems, but even partial adoption can make a big difference.

Basically that's it.

The above is the detailed content of What are SOLID principles in C ?. For more information, please follow other related articles on the PHP Chinese website!