设计模式部分-CSDN博客

本文链接：https://blog.csdn.net/qq_44401850/article/details/131807222

设计模式

创建型模式（Creational Patterns）

这些模式关注对象的创建过程，通过将对象的实例化与客户端代码的解耦来实现灵活性和可维护性。常见的创建型模式包括：工厂模式、抽象工厂模式、单例模式、原型模式和建造者模式。

单例模式

定义
单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问该实例。单例模式常用于需要限制实例化次数、在系统中共享资源或控制一些共享操作的情况下。

#include <stdio.h>

// 定义全局变量作为单例实例
static Singleton* instance = NULL;

// 定义单例结构体
typedef struct {
    // 添加需要共享的数据成员
    int data;
} Singleton;

// 获取单例实例的函数
Singleton* getSingletonInstance() {
    if (instance == NULL) {
        // 创建新的实例
        instance = (Singleton*)malloc(sizeof(Singleton));
        instance->data = 0;
    }
    return instance;
}

int main() {
    // 获取单例实例
    Singleton* singleton = getSingletonInstance();

    // 使用单例实例
    singleton->data = 10;
    printf("Data: %d\n", singleton->data);

    return 0;
}

备注: 上述示例中的单例模式不考虑多线程的并发访问情况。如果在多线程环境下使用单例模式，需要考虑线程安全性，可以使用互斥锁等机制来保证只有一个线程能够创建实例

工厂模式

工厂模式是一种创建对象的设计模式，它提供了一种统一的方式来创建不同类型的对象，而无需直接指定其具体的类。工厂模式通过将对象的实例化过程封装在一个工厂类中，客户端只需要与工厂类进行交互，而不需要关心具体的对象创建细节。
在C语言中，可以使用函数指针作为工厂模式的一种实现方式
是通过使用一个共同的接口来指向新创建的对象

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

// 定义产品类型
typedef enum {
    ProductA,
    ProductB
} ProductType;

// 产品结构体
typedef struct {
    ProductType type;
    // 其他成员
} Product;

// 创建产品A的函数
Product* createProductA() {
    Product* product = (Product*)malloc(sizeof(Product));
    product->type = ProductA;
    // 其他初始化操作
    return product;
}

// 创建产品B的函数
Product* createProductB() {
    Product* product = (Product*)malloc(sizeof(Product));
    product->type = ProductB;
    // 其他初始化操作
    return product;
}

// 工厂函数，根据产品类型返回对应的函数功能
Product* createProduct(ProductType type) {
    switch (type) {
        case ProductA:
            return createProductA();
        case ProductB:
            return createProductB();
        default:
            return NULL;
    }
}

int main() {
    // 使用工厂函数创建产品，实例化
    Product* productA = createProduct(ProductA);
    Product* productB = createProduct(ProductB);

    // 使用产品
    printf("Product A type: %d\n", productA->type);
    printf("Product B type: %d\n", productB->type);

    // 释放资源
    free(productA);
    free(productB);

    return 0;
}

例子2 定义抽象方法的函数指针类型，把这个类型用于结构体里面（可以在结构体里面放Struct 以及对这个Struct操作的方法类型），然后实例化结构体（变量赋值），定义具体的方法，最后赋值方法.

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

// 定义抽象方法的函数指针类型
typedef void (*AbstractMethod)();

// 定义包含抽象方法的结构体
typedef struct {
    AbstractMethod method;
} AbstractStruct;

// 具体实现的方法1
void concreteMethod1() {
    printf("This is concrete method 1.\n");
}

// 具体实现的方法2
void concreteMethod2() {
    printf("This is concrete method 2.\n");
}

// 实例化结构体并调用抽象方法
AbstractStruct* createAbstractStruct(int size) {
    AbstractStruct* instance = malloc(size * sizeof(AbstractStruct));
    return instance;
}

int main() {
    int size = 3;
    // 创建结构体数组实例
    AbstractStruct* myStructArray = createAbstractStruct(size);

    // 初始化结构体数组中的元素，指定具体实现的方法1和方法2
    myStructArray[0].method = concreteMethod1;
    myStructArray[1].method = concreteMethod2;
    myStructArray[2].method = concreteMethod1;

    // 调用结构体数组中的抽象方法
    for (int i = 0; i < size; i++) {
        myStructArray[i].method();
    }

    // 释放内存
    free(myStructArray);

    return 0;
}