下面我为你整理了一份详尽的 C语言设计模式学习指南，包含核心思想、实现方式、推荐资源和学习路径，希望能帮助你系统地学习。

为什么要在C语言中使用设计模式？

在学习具体模式之前,先明白为什么要这么做：

1. 提升代码可读性：设计模式是“被验证过的解决方案”，遵循它能让其他开发者快速理解你的代码意图。
2. 增强代码可维护性：模块化、低耦合的设计使得修改、替换或扩展某个功能变得非常容易。
3. 提高代码复用性：将通用的解决方案抽象成模式，可以在项目中反复使用。
4. 弥补C语言的不足：C语言没有类、继承、多态等OOP特性，设计模式可以模拟这些特性，实现更复杂的逻辑。

C语言实现设计模式的核心技巧

在C中实现模式,我们主要依赖以下工具：

• 结构体：用于封装数据，模拟 class。
• 函数指针：用于封装行为，模拟 virtual method 或 interface。
• 函数指针结构体：将一组相关的函数指针组织在一起，模拟 class 的方法集，实现 interface。
• 内存管理：malloc/free 用于创建和销毁对象。
• 头文件与模块化：通过 .h 和 .c 文件分离接口和实现。

核心设计模式在C语言中的实现（附示例）

这里选择几个最常用和最经典的模式进行讲解。

单例模式

目的：保证一个类只有一个实例，并提供一个全局访问点。

C语言实现思路：

• 使用一个全局静态指针来保存唯一实例。
• 构造函数私有化（在C中，就是不提供外部调用的创建函数）。
• 提供一个公共的获取实例的函数,该函数会检查实例是否已创建，如果未创建则创建它。

示例代码：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H
typedef struct {
    int data;
} Singleton;
// 获取单例实例
Singleton* get_instance();
#endif // SINGLETON_H

// singleton.c
#include "singleton.h"
#include <stdlib.h>
// 静态全局指针，保存唯一实例
static Singleton* instance = NULL;
// 获取单例实例
Singleton* get_instance() {
    if (instance == NULL) {
        instance = (Singleton*)malloc(sizeof(Singleton));
        if (instance != NULL) {
            instance->data = 0; // 初始化
        }
    }
    return instance;
}
// 注意：在实际项目中，还需要一个销毁单例的函数来释放内存
// void destroy_instance() { free(instance); instance = NULL; }

工厂模式

目的：定义一个用于创建对象的接口，让子类决定实例化哪一个类，将实例的创建与使用分离。

C语言实现思路：

• 定义一个“产品”结构体，作为所有具体产品的基类（或接口）。
• 定义多个具体的产品结构体。
• 定义一个“工厂”结构体，其中包含一个函数指针，这个指针会根据输入创建并返回不同的产品。

示例代码：

// product.h
#ifndef PRODUCT_H
#define PRODUCT_H
// 产品接口
typedef struct {
    void (*show)(void* this);
} Product;
#endif // PRODUCT_H

// product_a.h
#ifndef PRODUCT_A_H
#define PRODUCT_A_H
#include "product.h"
// 具体产品A
typedef struct {
    Product base; // 继承接口
    char name[20];
} ProductA;
// 创建产品A的函数
ProductA* create_product_a();
#endif // PRODUCT_A_H

// product_a.c
#include "product_a.h"
#include <stdio.h>
#include <string.h>
void show_product_a(void* this) {
    ProductA* pa = (ProductA*)this;
    printf("This is Product A, name: %s\n", pa->name);
}
ProductA* create_product_a() {
    ProductA* pa = (ProductA*)malloc(sizeof(ProductA));
    if (pa) {
        pa->base.show = show_product_a; // 绑定方法
        strcpy(pa->name, "Alpha");
    }
    return pa;
}

// factory.h
#ifndef FACTORY_H
#define FACTORY_H
#include "product.h"
// 工厂函数，根据类型创建产品
Product* create_product(int type);
#endif // FACTORY_H

// factory.c
#include "factory.h"
#include "product_a.h"
// #include "product_b.h" // 假设有ProductB
Product* create_product(int type) {
    switch (type) {
        case 1:
            return (Product*)create_product_a();
        // case 2:
        //     return (Product*)create_product_b();
        default:
            return NULL;
    }
}

观察者模式

目的：定义对象间的一种一对多依赖关系，当一个对象状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

C语言实现思路：

• 主题：维护一个观察者列表，提供注册、注销和通知观察者的方法。
• 观察者：提供一个回调函数接口，当被通知时执行。

示例代码：

// observer.h
#ifndef OBSERVER_H
#define OBSERVER_H
// 观察者接口
typedef struct {
    void (*update)(void* this, int state);
} Observer;
#endif // OBSERVER_H

// subject.h
#ifndef SUBJECT_H
#define SUBJECT_H
#include "observer.h"
// 主题
typedef struct {
    Observer** observers;
    int observer_count;
    int state;
} Subject;
void subject_init(Subject* s);
void subject_attach(Subject* s, Observer* o);
void subject_detach(Subject* s, Observer* o);
void subject_notify(Subject* s);
void subject_set_state(Subject* s, int new_state);
#endif // SUBJECT_H

// subject.c
#include "subject.h"
#include <stdlib.h>
void subject_init(Subject* s) {
    s->observers = NULL;
    s->observer_count = 0;
    s->state = 0;
}
void subject_attach(Subject* s, Observer* o) {
    s->observers = realloc(s->observers, (s->observer_count + 1) * sizeof(Observer*));
    s->observers[s->observer_count++] = o;
}
void subject_detach(Subject* s, Observer* o) {
    // 简化版，实际需要查找并移除
    (void)s; (void)o; // 避免警告
}
void subject_notify(Subject* s) {
    for (int i = 0; i < s->observer_count; i++) {
        s->observers[i]->update(s->observers[i], s->state);
    }
}
void subject_set_state(Subject* s, int new_state) {
    s->state = new_state;
    subject_notify(s);
}

策略模式

目的：定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。

C语言实现思路：

• 定义一个“策略”接口，包含一个执行算法的函数指针。
• 定义多个具体的策略结构体,实现该接口。
• 上下文对象持有一个策略接口的指针,可以在运行时动态切换策略。

示例代码：

// strategy.h
#ifndef STRATEGY_H
#define STRATEGY_H
// 策略接口
typedef struct {
    int (*execute)(int a, int b);
} Strategy;
#endif // STRATEGY_H

// add_strategy.h
#ifndef ADD_STRATEGY_H
#define ADD_STRATEGY_H
#include "strategy.h"
// 加法策略
typedef struct {
    Strategy base;
} AddStrategy;
AddStrategy* create_add_strategy();
#endif // ADD_STRATEGY_H

// add_strategy.c
#include "add_strategy.h"
int add(int a, int b) {
    return a + b;
}
AddStrategy* create_add_strategy() {
    AddStrategy* s = (AddStrategy*)malloc(sizeof(AddStrategy));
    if (s) {
        s->base.execute = add;
    }
    return s;
}

// context.h
#ifndef CONTEXT_H
#define CONTEXT_H
#include "strategy.h"
// 上下文
typedef struct {
    Strategy* strategy;
} Context;
void context_init(Context* c);
void context_set_strategy(Context* c, Strategy* s);
void context_execute(Context* c, int a, int b);
#endif // CONTEXT_H

// context.c
#include "context.h"
#include <stdio.h>
void context_init(Context* c) {
    c->strategy = NULL;
}
void context_set_strategy(Context* c, Strategy* s) {
    c->strategy = s;
}
void context_execute(Context* c, int a, int b) {
    if (c->strategy) {
        int result = c->strategy->execute(a, b);
        printf("Result: %d\n", result);
    } else {
        printf("No strategy set!\n");
    }
}

推荐视频教程资源

由于专门针对“C语言设计模式”的视频教程相对较少，很多优秀的资源是讲座、分享或书籍的配套视频，以下是一些高质量的推荐：

经典讲座与分享

• Kevlin Henney - "Coding with Patterns"

  • 简介：Kevlin是一位非常著名的软件模式专家，他的讲座深入浅出，不仅限于C++或Java，而是从更通用的视角讲解模式如何应用于各种语言，包括C，他的风格风趣幽默，能让你深刻理解模式的本质，而不仅仅是语法。
  • 搜索关键词："Kevlin Henney Coding with Patterns"。
  • 平台：YouTube, InfoQ等。

• "C++ Seasoning" by Sean Parent (部分内容适用于C)

  • 简介：Sean Parent是Adobe的资深工程师，他在C++领域对现代C++和设计模式的应用有非常深刻的见解，虽然主讲C++，但他大量使用了C的思维方式（如类型擦除、PImpl等），其关于接口、组合、继承的讲解对C语言开发者极具启发意义，他的很多思想可以直接应用到C中。
  • 搜索关键词："Sean Parent C++ Seasoning"。
  • 平台：YouTube (CppCon大会视频)。

• "C++ and Beyond" 系列会议

  • 简介：这个系列会议有很多高质量演讲，其中关于设计模式、现代C++技巧的分享非常多，同样，你可以从中汲取很多适用于C的思想。
  • 搜索关键词："C++ and Beyond design patterns"。
  • 平台：YouTube。

国内优质视频教程

• Bilibili (B站)

  • B站是学习编程的宝库,搜索时可以尝试使用中文和英文关键词。
  • 搜索关键词：
    • C语言 设计模式
    • C语言 高级编程
    • C语言 面向对象
    • C语言 工厂模式 单例模式 (直接搜索具体模式)
  • 推荐UP主：搜索一些专注于C/C++、系统编程的UP主，如 “李慧文”、“同济大学-谭浩强”（经典教材作者，虽然风格可能较老，但基础扎实）、“清华大学-陈越” 等，他们的课程中可能会涉及相关思想。

• CSDN / 慕课网 / 极客时间

  • 这些平台有大量付费或免费的课程,你可以搜索“C语言设计模式”或“C++设计模式”，因为C++的实现方式对C有很强的参考价值。
  • 优点：系统性强，有完整的课程体系和练习。
  • 缺点：质量参差不齐，需要甄别。

配套书籍的视频讲解

• 《设计模式：可复用面向对象软件的基础》（GoF Gang of Four）

  • 简介：设计模式的“圣经”，虽然书中的例子是C++和Smalltalk，但23个模式的原理是通用的，你可以先看书理解模式，然后在B站或YouTube上搜索别人讲解GoF模式的视频，结合自己的C语言知识进行实现。
  • 搜索关键词："GoF design patterns explained"。

• 《C++设计新思维》 (Modern C++ Design by Andrei Alexandrescu)

  • 简介：这本书极度推崇在C++中使用模板和泛型编程来实现高级设计模式（如Policy-Based Design），它展示了C++语言的强大威力，其中很多关于接口、类型擦除、动态多态的思想，对于用C实现模式有巨大的启发作用。
  • 搜索关键词："Andrei Alexandrescu Modern C++ Design"。

学习路径建议

1. 打好基础：确保你对C语言的指针、结构体、函数指针、内存管理有非常扎实的理解，这是实现设计模式的前提。
2. 从模式开始：不要一开始就啃厚厚的理论书，先从单例模式和工厂模式这两个最简单的模式入手，尝试自己用C语言实现一遍。
3. 理解，而非记忆：关键是理解每个模式要解决什么问题（Why），而不是死记它的结构（What），理解了“为什么要解耦”，你就能明白为什么工厂模式要把创建和使用分开。
4. 阅读优秀源码：去阅读一些知名开源C项目（如 Redis, Nginx, SQLite, Git）的源码，看看它们是如何组织代码、处理模块间关系的，你可能会发现它们在不经意间使用了设计模式的思想。
5. 动手实践：找一个小项目（比如一个命令行工具、一个简单的游戏），尝试用你学到的模式去重构它，实践是检验学习成果的唯一标准。
6. 循序渐进：掌握基础模式后，再学习观察者、策略、装饰器等更复杂的模式。

祝你学习顺利！掌握C语言的设计模式，会让你的代码水平提升一个档次。