抽象工厂模式 （C语言实现）

最新推荐文章于 2023-11-26 15:54:19 发布
最新推荐文章于 2023-11-26 15:54:19 发布
阅读量2.1k 收藏 4
点赞数 1
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hmsiwtv/article/details/32375581
版权

工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。


三. 抽象工厂模式

抽象工厂模式，它定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

还以上面的例子解释，这家公司经营的还不错，针对其核心技术都申请了专利，后来生始生产相关电子芯片了 (像三星一样，即生产产品也生产芯片)。对于这种情况，我们不能在抽象产品类上继承一个零部件，因为产品和芯片没有什么共同之处，完全是两个领域。你要做芯片，就要专心做，当成一个新的领域，不能用以前产品的那一套流程。这样划分才明确，才能更好的实现高内聚，低耦合的明标。

abstractClass.h

#ifndef ABSTRACTCLASS_H
#define ABSTRACTCLASS_H

#include <stdlib.h>
#include <stdarg.h>

typedef struct {
    size_t size;
    void* (*ctor)(void *_self, va_list *params);
    void* (*dtor)(void *_self);
} AbstractClass;

#endif

chip.h 

#ifndef CHIP_H
#define CHIP_H

#include <stdlib.h>
#include <stdarg.h>

typedef struct {
    size_t size;
    void* (*ctor)(void *_self, va_list *params);
    void* (*dtor)(void *_self);
    void (*show)(const void *_self);
} Chip;

#endif

chipA.h 

#ifndef CHIPA_H
#define CHIPA_H

typedef struct {
    const void *_;
} _ChipA;

extern const void *ChipA;

#endif

chipA.c 

#include "chip.h"
#include "chipA.h"
#include <stdarg.h>
#include <stdio.h>

static void *chipACtor(void *_self, va_list *params) {
    _ChipA *self = _self;

    return self;
}

static void *chipADtor(void *_self) {
    _ChipA *self = _self;

    return self;
}

static void chipAShow(const void *_self) {
    (void)_self;
    fprintf(stdout, "Chip A\n");
}

static const Chip _chip = {
    sizeof(_ChipA),
    chipACtor,
    chipADtor,
    chipAShow
};

const void *ChipA = &_chip;

chipB.h 

#ifndef CHIPB_H
#define CHIPB_H

typedef struct {
    const void *_;
} _ChipB;

extern const void *ChipB;

#endif

chipB.c 

#include "chip.h"
#include "chipB.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>

static void *chipBCtor(void *_self, va_list *params) {
    _ChipB *self = _self;

    return self;
}

static void *chipBDtor(void *_self) {
    _ChipB *self = _self;

    return self;
}

static void chipBShow(const void *_self) {
    (void)_self;
    fprintf(stdout, "Chip B\n");
}

static const Chip _chip = {
    sizeof(_ChipB),
    chipBCtor,
    chipBDtor,    
    chipBShow
};

const void *ChipB = &_chip;

factory.h 

#ifndef FACTORY_H
#define FACTORY_H

#include <stdlib.h>
#include <stdarg.h>

typedef struct {
    size_t size;
    void* (*ctor)(void *_self, va_list *params);
    void* (*dtor)(void *_self);
    void* (*createProduct)(const void *_self);
    void* (*createChip)(const void *_self);
} Factory;

#endif

factoryA.h 

#ifndef FACTORYA_H
#define FACTORYA_H

typedef struct {
    const void *_;
} _FactoryA;

extern const void *FactoryA;


#endif

factoryA.c 

#include "factory.h"
#include "factoryA.h"
#include "productA.h"
#include "chipA.h"
#include "new.h"
#include <stdarg.h>

static void *factoryACtor(void *_self, va_list *params){
    _FactoryA *self = _self;

    return self;
}

static void *factoryADtor(void *_self) {
    _FactoryA *self = _self;

    return self;
}

static void* factoryACreateProduct(const void *self) {
    return New(ProductA);
}

static void* factoryACreateChip(const void *self) {
    return New(ChipA);
}

static const Factory _factory = {
    sizeof(_FactoryA),
    factoryACtor,
    factoryADtor,
    factoryACreateProduct,
    factoryACreateChip
};

const void *FactoryA = &_factory;

factoryB.h 

#ifndef FACTORYB_H
#define FACTORYB_H

typedef struct {
    const void *_;
} _FactoryB;

extern const void *FactoryB;

#endif

factoryB.c 

#include "factory.h"
#include "factoryB.h"
#include "productB.h"
#include "chipB.h"
#include "new.h"
#include <stdarg.h>

static void *factoryBCtor(void *_self, va_list *params){
    _FactoryB *self = _self;

    return self;
}

static void *factoryBDtor(void *_self) {
    _FactoryB *self = _self;

    return self;
}

static void* factoryBCreateProduct(const void *self) {
    return New(ProductB);
}

static void* factoryBCreateChip(const void *self) {
    return New(ChipB);
}

static const Factory _factory = {
    sizeof(_FactoryB),
    factoryBCtor,
    factoryBDtor,
    factoryBCreateProduct,
    factoryBCreateChip
};

const void *FactoryB = &_factory;

product.h 

#ifndef PRODUCT_H
#define PRODUCT_H

#include <stdlib.h>
#include <stdarg.h>

typedef struct {
    size_t size;
    void* (*ctor)(void *_self, va_list *params);
    void* (*dtor)(void *_self);
    void (*show)(const void *_self);
} Product;

#endif

productA.h 

#ifndef PRODUCTA_H
#define PRODUCTA_H

typedef struct {
    const void *_;
} _ProductA;

extern const void *ProductA;

#endif

productA.c 

#include "product.h"
#include "productA.h"
#include <stdarg.h>
#include <stdio.h>

static void *productACtor(void *_self, va_list *params) {
    _ProductA *self = _self;

    return self;
}

static void *productADtor(void *_self) {
    _ProductA *self = _self;

    return self;
}

static void productAShow(const void *_self) {
    (void)_self;
    fprintf(stdout, "Product A\n");
}

static const Product _product = {
    sizeof(_ProductA),
    productACtor,
    productADtor,
    productAShow
};

const void *ProductA = &_product;

productB.h 

#ifndef PRODUCTB_H
#define PRODUCTB_H

typedef struct {
    const void *_;
} _ProductB;

extern const void *ProductB;

#endif

productB.c 

#include "product.h"
#include "productB.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>

static void *productBCtor(void *_self, va_list *params) {
    _ProductB *self = _self;

    return self;
}

static void *productBDtor(void *_self) {
    _ProductB *self = _self;

    return self;
}

static void productBShow(const void *_self) {
    (void)_self;
    fprintf(stdout, "Product B\n");
}

static const Product _product = {
    sizeof(_ProductB),
    productBCtor,
    productBDtor,    
    productBShow
};

const void *ProductB = &_product;

new.h 

#ifndef NEW_H
#define NEW_H

void *New(const void *_class, ...);
void Delete(void *_class);
void *CreateProduct(const void *_factory);
void *CreateChip(const void *_factory);
void Show(const void *product);

#endif

new.c 

#include "new.h"
#include "abstractClass.h"
#include "factory.h"
#include "product.h"
#include <stdarg.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

void *New(const void *_class, ...) {
    const AbstractClass *class = _class;

    void *p = calloc(1, class->size);

    assert(p);
    *(const AbstractClass **)p = class;
    
    if (class->ctor) {
        va_list params;

        va_start(params, _class);
        p = class->ctor(p, ¶ms);
        va_end(params);
    }

    return p;
}

void Delete(void *_class) {
    const AbstractClass **class = _class;

    if (_class && *class && (*class)->dtor) {
        _class = (*class)->dtor(_class);
    }

    free(_class);
}

void *CreateProduct(const void *_factory) {
    const Factory * const *factory = _factory;
    if (_factory && *factory && (*factory)->createProduct) {
        return (*factory)->createProduct(_factory);
    } else {
        return NULL;
    }
}

void *CreateChip(const void *_factory) {
    const Factory * const *factory = _factory;
    if (_factory && *factory && (*factory)->createChip) {
        return (*factory)->createChip(_factory);
    } else {
        return NULL;
    }    
}

void Show(const void *_product) {
    const Product * const *product = _product;
    if (_product && *product && (*product)->show) {    
        (*product)->show(_product);
    }
}

main.c 

#include "new.h"
#include "factoryA.h"
#include "factoryB.h"

int main(int argc, char *argv[]) {
    void *facA = New(FactoryA);
    void *facB = New(FactoryB);

    void *pro1 = CreateProduct(facA);
    void *pro2 = CreateProduct(facB);
    void *pro3 = CreateProduct(facA);

    Show(pro1);
    Show(pro2);
    Show(pro3);

    void *pro4 = CreateChip(facA);
    void *pro5 = CreateChip(facB);
    void *pro6 = CreateChip(facA);

    Show(pro4);
    Show(pro5);
    Show(pro6);
    
    Delete(facA);
    Delete(facB);
    Delete(pro1);
    Delete(pro2);
    Delete(pro3);
    Delete(pro4);
    Delete(pro5);
    Delete(pro6);

    
    return 0;
}


Tyrion-Lannister
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言工厂模式
08-05
最近一直在看设计模式，想把自己的学习笔记与大家分享一下，如果能帮助大家的话，我会非常高兴，同时也欢迎大家指出里面的不足
设计模式之抽象工厂模式（C语言）
Hongggggggg
12-23 819
介绍： ​ 抽象工厂模式是一种创建型设计模式； 作用： ​ 提供统一的接口让用户根据不同的需求创建出不同的工厂； 类比： ​ 一个制造家具的工厂，可以根据用户不同的诉求，制造出不同风格的家具； 代码示例： 首先定义出不同类型的家具以供生产： void modern_chair(void) { printf("A modern chair\r\n"); } void modern_dest(void) { printf("A modern desk\r\n"); } void victor
通过实例说设计模式——抽象工厂模式
热门推荐
Ron.Zheng
06-15 3万+
工厂方法模式引入工厂等级结构，解决了简单工厂模式中工厂类职责过重的问题，但由于工厂方法模式中每个工厂只创建一类具体类的对象，这将会导致系统当中的工厂类过多，这势必会增加系统的开销。此时，我们可以考虑将一些相关的具体类组成一个“具体类族”，由同一个工厂来统一生产，这就是我们本文要说的“抽象工厂模式”的基本思想。 接着来看我们抽象方法模式一文中我们说的例子，我们现在有这么一个场景；现在用户的需求变多...
03-抽象工厂模式-C语言实现
最新发布
东辰叶落
11-26 174
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口或抽象类，用于创建相关或依赖对象的家族，而不需要指定具体的类。抽象工厂模式通过封装一组相关的产品对象的创建逻辑，使得客户端可以通过统一的接口来创建这些产品对象。需要注意的是，抽象工厂模式适合处理产品族的创建，而不适合处理单个产品的创建。另外，抽象工厂模式在系统中增加了抽象性，如果系统规模较小或者产品结构简单，可能会显得过度设计，此时可以考虑使用简单工厂模式。
什么叫抽象，编程中怎么理解抽象的概念。
Gy__My的博客
06-17 1万+
面向对象软件开发的一个基本方法就是抽象，到底什么是抽象呢? 抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。 例如苹果、香蕉、生梨、葡萄、桃子等，它们共同的特性就是水果。 得出水果概念的过程，就是一个抽象的过程。 要抽象，就必须进行比较，没有比较就无法找到共同的部分。 共同特征是指那些能把一类事物与他类事物区分开来的特征， 这些具有区分作用的特征又称本质特征。
三大工厂模式的代码实现及总结
ZJXin
08-05 2万+
转载请注明出处 作者：@LSZJXin 说明：本文借助冰激凌的例子，通过Java来实现三大工厂模式，代码运行无误。由于本人水平有限，如有不正确的地方，欢迎留言指出。谢谢！ 简单工厂模式、工厂方法模式、抽象工厂模式，都是属于创建型设计模式。严格上来说，简单工厂模式不属于23设计模式之一，因为它违背了开闭原则。这三种设计模式，名字都包含“工厂”二字，如果没有认真地对它们的设计思...
[c设计模式]抽象工厂模式 (from chatgpt)
陶宝大人的博客
03-16 109
抽象工厂模式是一种创建型设计模式，它允许客户端通过接口而不是具体类来创建相关对象的系列。在C语言中，我们可以使用函数指针和结构体来实现抽象工厂模式。这个示例中使用了C语言的结构体和函数指针实现了抽象工厂模式的核心机制，通过使用函数指针，我们可以轻松地切换具体产品的实现。在这个示例中，我们创建了两种不同的具体工厂（），每种工厂都能生产两种不同的抽象产品（
设计模式之抽象工厂模式(C++)
翟天保的博客
02-16 2万+
介绍设计模式之抽象工厂模式
工厂模式--C语言实现
05-30 793
工厂模式，其实就是C++中的类的继承，只不过用C语言中的函数指针来实现了。 假设现在的需求是公司生产一系列产品，包括椅子，床等，要求先生产产品，然后将生产的产品销售出去。将来可能要增加新的产品，不希望修改现有的核心代码流程，满足开闭原则。 /* 工厂模式，其实就是C++中的类的继承，只不过用C语言中的函数指针来实现了 */ /* 假设现在的需求是公司生产一系列产品，包括椅子，床等，要求先生产产品，然后将 生产的产品销售出去。 将来可能要增加新的产品，不希望修改现有的核
C语言实现抽象工厂模式
wangzhicheng2013的专栏
04-01 999
#include <stdio.h> #include <stdlib.h> typedef struct _Coffee { void (*have_coffee)(); } Coffee; typedef struct _Tea { void (*have_tea)(); } Tea; void have_black_coffee() { printf("have black coffee!\n"); } void have_white_coffee(.
用C语言实现简单工厂模式！
weixin_46564301的博客
03-12 448
虽然C语言是面向过程的编程语言，但是我们在设计程序的时候，可以考虑用面向对象的方式去设计，这样提高我们程序的“高内聚、低耦合”特性，便于维护。
抽象工厂模式的简单实现
03-13
抽象工厂模式的简单实现
java实现工厂模式-抽象工厂模式
06-14
抽象工厂模式定义了一组抽象的工厂接口，具体的工厂类实现这些接口来创建一系列相关的产品对象。
python 实现 抽象工厂模式
06-07
python 实现 抽象工厂模式
抽象工厂模式实现
11-19
抽象工厂模式实现 代码来自：http://www.cnblogs.com/zhili/p/AbstractFactory.html
设计模式实现——抽象工厂模式结构实现
09-03
写博客上传的代码：blog http://blog.csdn.net/t1234xy4/article/details/52424048
C语言对象编程一:封装与抽象
zhen
05-20 854
文章来源：C语言对象编程第一弹：封装与抽象 前言 上次整理了一篇关于面向对象的笔记：《什么是面向对象？》。简单地分享了面向对象的一些基础知识。 C语言虽不是面向对象的语言，但也可以使用面向对象的思想来设计我们的程序。 C语言 + 面向对象的思想在我们嵌入式中使用得很广泛，主要优点就是能使我们的软件拓展性更好、更易读、更容易维护等。 因为这一块知识也比较重要，属于通用知识，所以打算分享几篇笔记与大家一起学习一下。 当然，C语言并不是面向对象的语言，要想完全实现与C++一样的一些面向对象的特性会比较难。所以.
C语言实现简单工厂模式
lijianhua003的博客
08-17 1131
工厂模式是一种面向对象的模式，是23种里面的一种，c语言是面向过程，但我们可以用类与对象（结构体）实现一个简单的面向对象模式，跟分文件编程很像。
C语言设计模式——简单工厂模式
穿越临界点的博客
05-08 3614
设计模式是学习和使用面向对象编程不可绕过的一个里程碑，学习设计模式有助于深入理解和灵活使用面向对象思想，设计出更高质量的代码。
用c语言实现抽象工厂模式
04-01
抽象工厂模式是一种创建型设计模式，它允许客户端代码使用抽象接口来创建一组相关或依赖对象，而无需指定其具体类。 在C语言中，可以使用函数指针来模拟抽象类和虚函数，从而实现抽象工厂模式。 下面是一个简单的示例，演示如何使用C语言实现抽象工厂模式： ```c #include <stdio.h> // 定义抽象产品1接口 typedef struct { void (*operation1)(void); } AbstractProduct1; // 定义抽象产品2接口 typedef struct { void (*operation2)(void); } AbstractProduct2; // 定义抽象工厂接口 typedef struct { AbstractProduct1* (*createProduct1)(void); AbstractProduct2* (*createProduct2)(void); } AbstractFactory; // 定义具体产品1A typedef struct { AbstractProduct1 base; } Product1A; // 实现具体产品1A的操作1 static void operation1A(void) { printf("Product 1A Operation 1\n"); } // 定义具体产品2A typedef struct { AbstractProduct2 base; } Product2A; // 实现具体产品2A的操作2 static void operation2A(void) { printf("Product 2A Operation 2\n"); } // 定义具体工厂A typedef struct { AbstractFactory base; } FactoryA; // 实现具体工厂A的createProduct1函数 static AbstractProduct1* createProduct1A(void) { Product1A* product = malloc(sizeof(Product1A)); product->base.operation1 = operation1A; return &product->base; } // 实现具体工厂A的createProduct2函数 static AbstractProduct2* createProduct2A(void) { Product2A* product = malloc(sizeof(Product2A)); product->base.operation2 = operation2A; return &product->base; } // 定义具体产品1B typedef struct { AbstractProduct1 base; } Product1B; // 实现具体产品1B的操作1 static void operation1B(void) { printf("Product 1B Operation 1\n"); } // 定义具体产品2B typedef struct { AbstractProduct2 base; } Product2B; // 实现具体产品2B的操作2 static void operation2B(void) { printf("Product 2B Operation 2\n"); } // 定义具体工厂B typedef struct { AbstractFactory base; } FactoryB; // 实现具体工厂B的createProduct1函数 static AbstractProduct1* createProduct1B(void) { Product1B* product = malloc(sizeof(Product1B)); product->base.operation1 = operation1B; return &product->base; } // 实现具体工厂B的createProduct2函数 static AbstractProduct2* createProduct2B(void) { Product2B* product = malloc(sizeof(Product2B)); product->base.operation2 = operation2B; return &product->base; } int main() { // 创建具体工厂A FactoryA factoryA; factoryA.base.createProduct1 = createProduct1A; factoryA.base.createProduct2 = createProduct2A; // 使用具体工厂A创建产品 AbstractProduct1* product1A = factoryA.base.createProduct1(); AbstractProduct2* product2A = factoryA.base.createProduct2(); // 调用产品的操作 product1A->operation1(); product2A->operation2(); // 创建具体工厂B FactoryB factoryB; factoryB.base.createProduct1 = createProduct1B; factoryB.base.createProduct2 = createProduct2B; // 使用具体工厂B创建产品 AbstractProduct1* product1B = factoryB.base.createProduct1(); AbstractProduct2* product2B = factoryB.base.createProduct2(); // 调用产品的操作 product1B->operation1(); product2B->operation2(); return 0; } ``` 在上面的示例中，我们定义了抽象产品1和抽象产品2的接口，以及抽象工厂的接口。然后使用具体的产品和工厂来实现这些接口。最后，我们可以使用具体工厂来创建具体产品，并调用它们的操作。 需要注意的是，在C语言中，需要手动管理内存，因此需要在使用完产品后释放它们的内存。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值