Table of Contents

Definition

Design patterns in C are reusable architectural solutions to common software engineering problems, adapted to C's procedural paradigm, manual memory management, and lack of native object-oriented features. Instead of classes, inheritance, and automatic lifecycle management, C patterns rely on structures, function pointer tables, opaque pointers, explicit interfaces, and disciplined ownership contracts to achieve polymorphism, encapsulation, and separation of concerns.

C-Specific Implementation Foundations

OOP Concept	C Equivalent	Mechanism
Class	`struct` + associated functions	Data layout + explicit `init()`/`destroy()`/`method()` APIs
Polymorphism	Function pointer tables (vtables)	`typedef struct { int (exec)(void ctx); } VTable;`
Inheritance	Struct embedding	Base struct must be the first member for safe casting
Encapsulation	Opaque pointers + header/source split	`typedef struct Module Module;` in `.h`, full definition in `.c`
Interfaces	Struct of function pointers	Uniform `void *ctx` parameter enables generic dispatch
Exceptions	Error codes + `goto cleanup`	Return status, `errno`, or context error fields with deterministic teardown

Common Patterns & C Implementations

1. Strategy Pattern (Runtime Algorithm Selection)

typedef struct {
int (*compute)(int a, int b);
const char *name;
} Strategy;
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
void run_strategy(const Strategy *s, int x, int y) {
printf("%s: %d\n", s->name, s->compute(x, y));
}

2. Observer Pattern (Event Notification)

typedef void (*NotifyFunc)(void *ctx, int event);
typedef struct Observer { NotifyFunc callback; void *ctx; struct Observer *next; } Observer;
typedef struct { Observer *head; int state; } Subject;
void attach(Subject *s, Observer *o) { o->next = s->head; s->head = o; }
void notify(Subject *s, int event) {
for (Observer *o = s->head; o; o = o->next) o->callback(o->ctx, event);
}

3. Object Pool Pattern (Fixed Allocation)

Pre-allocates a contiguous block, subdivides it into fixed-size chunks, and maintains a free list. Eliminates malloc/free overhead, prevents fragmentation, and guarantees O(1) allocation. Essential for embedded, real-time, and high-throughput systems.

4. Singleton Pattern (Controlled Global Access)

static Config *instance = NULL;
Config *get_config(void) {
if (!instance) instance = init_config(); // Not thread-safe without synchronization
return instance;
}

Rules & Constraints

No Native Polymorphism: Dispatch tables must be explicitly populated and validated. Missing entries cause segmentation faults.
Memory Ownership is Explicit: Patterns implying automatic cleanup require symmetrical init/destroy functions and deterministic error paths.
Struct Layout Matters: Polymorphic base structs must be embedded as the first member to enable safe (Base *) casting.
Thread Safety Not Guaranteed: Shared state, pools, or singletons require explicit synchronization (pthread_mutex_t, C11 atomics) for concurrent use.
No Exceptions: Error propagation relies on return codes and cleanup labels. Control flow must remain predictable.

Best Practices

Use opaque pointers for encapsulation: Expose only forward declarations in headers. Hide implementation details and internal state in .c files.
Standardize function pointer signatures: Use void *ctx as the first parameter to enable uniform callback, observer, and strategy dispatch.
Prefer composition over inheritance: Embed structs explicitly rather than simulating deep hierarchies. Reduces casting complexity and improves cache locality.
Implement explicit init/cleanup pairs: Every pattern that allocates or registers state must provide symmetrical teardown functions.
Document ownership semantics: Clearly state whether the caller, callee, or pattern runtime frees resources, especially in callback and observer lists.
Use static inline for lightweight patterns: Small helper functions in headers reduce call overhead and enable compiler inlining without linker bloat.

Common Pitfalls

🔴 Simulating OOP verbatim: Over-engineering vtables and inheritance hierarchies adds complexity without C++ compiler optimizations or automatic memory management.
🔴 Uninitialized function pointers: Missing dispatch table entries or NULL callbacks cause runtime crashes.
🔴 Hidden global state: Singletons or facades relying on file-scope variables break reentrancy, prevent parallel testing, and complicate multi-threaded use.
🔴 Memory leaks in observer/callback lists: Failing to detach observers before subject destruction leads to dangling pointer invocations.
🔴 Assuming thread safety: Static instances or shared pools without locks cause race conditions, double-frees, or corrupted state in concurrent contexts.
🔴 Ignoring strict aliasing: Casting between unrelated struct pointers for "polymorphism" violates C aliasing rules and breaks under -O2/-O3.
🔴 Overusing patterns for simple logic: Direct function calls, enums, or table-driven dispatch are often clearer, faster, and easier to maintain than simulated design patterns.

Standards & Tooling Evolution

C Standard: No built-in pattern support. Patterns are architectural conventions implemented using core language features and disciplined coding practices.
C99/C11: Designated initializers, flexible array members, and _Thread_local simplify state management and thread-aware pattern implementations.
C17/C23: _Static_assert, improved diagnostics, and _Generic (C11) enable compile-time dispatch and pattern validation without runtime overhead.
Compiler Diagnostics: -Wmissing-field-initializers, -Wnull-dereference, -Wstrict-prototypes, and -Wcast-align enforce pattern correctness and catch unsafe casting early.
Static Analysis: clang-tidy, cppcheck, Coverity, and Infer detect memory ownership violations, callback mismatches, uninitialized dispatch tables, and aliasing risks.
Industry Adoption: Ubiquitous in Linux kernel (kobject, notifier chains, device drivers), embedded RTOS (FreeRTOS queues/tasks), GUI toolkits (GTK/LVGL signal routing), and network stacks (protocol handlers, state machines).
Modern Alternatives: Arena allocators and slab memory replace object pools in high-throughput systems. Explicit state machines, table-driven dispatch, and _Generic compile-time polymorphism often outperform simulated OOP patterns in performance-critical C code.

Design patterns in C require disciplined adaptation to procedural constraints. By leveraging opaque pointers, function pointer tables, explicit lifecycle management, and clear ownership contracts, developers can achieve the same architectural benefits as object-oriented languages while preserving C's performance, portability, and low-level control.

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers