【揭秘C语言中的面向对象设计模式】实用PDF指南，轻松掌握编程精髓

发布时间：2025-06-08 02:37:48

引言

面向东西计划形式是软件工程中一种重要的计划头脑，它经由过程将现实世界中的东西抽象成软件中的类跟东西，使得代码愈加模块化、可重用跟易于保护。尽管C言语本身不是面向东西的编程言语，但我们可能经由过程一些技能跟计划形式来实现类似面向东西的计划。本文将为你供给一份实用的PDF指南，帮助你轻松控制C言语中的面向东西计划形式。

目录

  1. C言语与面向东西计划形式
  2. 计划形式基本
  3. 常用面向东西计划形式
    • 单例形式
    • 工厂形式
    • 战略形式
    • 察看者形式
  4. 现实案例
  5. 总结

1. C言语与面向东西计划形式

C言语作为一种过程式编程言语，并不内建面向东西的特点，如类跟持续。但是，我们可能经由过程构造体、函数指针跟宏等机制来模仿面向东西的计划形式。

2. 计划形式基本

在计划形式中，有多少个核心不雅点：

  • 封装：将数据与操纵数据的方法封装在一同，暗藏外部实现细节。
  • 持续：容许一个类持续另一个类的属性跟方法。
  • 多态：容许差别类的东西对同一消息做出呼应。
  • 组合：将多个东西组剖析一个更大年夜的东西。

3. 常用面向东西计划形式

3.1 单例形式

单例形式确保一个类只有一个实例，并供给一个全局拜访点。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int value;
} Singleton;

Singleton* getInstance() {
    static Singleton instance = {0};
    return &instance;
}

int main() {
    Singleton* s1 = getInstance();
    Singleton* s2 = getInstance();

    printf("s1: %d\n", s1->value);
    printf("s2: %d\n", s2->value);

    return 0;
}

3.2 工厂形式

工厂形式用于创建东西，而不直接指定东西范例，从而让类的计划愈加机动。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void (*doSomething)(void);
} Product;

typedef struct {
    Product* (*createProduct)(void);
} Factory;

Product* createProductA() {
    Product* p = (Product*)malloc(sizeof(Product));
    p->doSomething = doSomethingA;
    return p;
}

Product* createProductB() {
    Product* p = (Product*)malloc(sizeof(Product));
    p->doSomething = doSomethingB;
    return p;
}

void doSomethingA() {
    printf("Doing something A\n");
}

void doSomethingB() {
    printf("Doing something B\n");
}

Factory factoryA = {createProductA};
Factory factoryB = {createProductB};

int main() {
    Product* pA = factoryA.createProduct();
    Product* pB = factoryB.createProduct();

    pA->doSomething();
    pB->doSomething();

    free(pA);
    free(pB);

    return 0;
}

3.3 战略形式

战略形式容许在运转时抉择算法的行动。

#include <stdio.h>
#include <stdlib.h>

typedef void (*Strategy)(void);

typedef struct {
    Strategy strategy;
} Context;

void strategyA() {
    printf("Using strategy A\n");
}

void strategyB() {
    printf("Using strategy B\n");
}

void setStrategy(Context* ctx, Strategy strategy) {
    ctx->strategy = strategy;
}

void runStrategy(Context* ctx) {
    ctx->strategy();
}

int main() {
    Context ctx;
    setStrategy(&ctx, strategyA);
    runStrategy(&ctx);

    setStrategy(&ctx, strategyB);
    runStrategy(&ctx);

    return 0;
}

3.4 察看者形式

察看者形式定义东西间的一对多依附关联，当一个东西改变状况时，全部依附于它的东西都会掉掉落告诉并主动更新。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void (*update)(void*);
} Observer;

typedef struct {
    Observer* observers;
    int observerCount;
} Subject;

void updateObserver(Observer* observer, void* data) {
    observer->update(data);
}

void addObserver(Subject* subject, Observer* observer) {
    subject->observers = realloc(subject->observers, (subject->observerCount + 1) * sizeof(Observer));
    subject->observers[subject->observerCount++] = observer;
}

void notifyObservers(Subject* subject) {
    for (int i = 0; i < subject->observerCount; i++) {
        updateObserver(&subject->observers[i], subject);
    }
}

typedef struct {
    int value;
} Data;

void observerUpdate(void* data) {
    Data* d = (Data*)data;
    printf("Observer received value: %d\n", d->value);
}

int main() {
    Subject subject;
    subject.observers = NULL;
    subject.observerCount = 0;

    Observer observer = {observerUpdate};

    Data data = {42};
    addObserver(&subject, &observer);

    notifyObservers(&subject);

    return 0;
}

4. 现实案例

以上代码示例展示了如何在C言语中实现一些基本的面向东西计划形式。你可能将这些形式利用到现实的项目中，以进步代码的可保护性跟可扩大年夜性。

5. 总结

经由过程进修C言语中的面向东西计划形式，你可能更好地懂得面向东西编程的头脑，并在C言语项目中利用这些形式。固然C言语本身不是面向东西的，但经由过程这些形式，你可能在C言语中实现类似面向东西的计划，从而进步代码的品质。

盼望这份实用的PDF指南可能帮助你轻松控制C言语中的面向东西计划形式。