建造模式C语言实现

最新推荐文章于 2023-02-08 07:30:35 发布
最新推荐文章于 2023-02-08 07:30:35 发布
阅读量3k 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tandesir/article/details/8656303
版权

【说明】建造模式的C语言实现，改写自http://blog.youkuaiyun.com/sx_wpc/article/details/7659179一文的代码。

【代码清单】

typedef.h

#ifndef __TYPEDEF_H__
#define __TYPEDEF_H__

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

#ifdef __cplusplus
extern "C" {
#endif

typedef enum _Ret
{
	RET_OK,
	RET_FAIL
}Ret;

#define return_if_fail(p)\
	if(!(p)){\
	printf("%s:%d Warning:"#p"Failed\n",__func__,__LINE__);\
	return;}
#define return_val_if_fail(p, ret)\
	if(!(p)){\
	printf("%s:%d Warning:"#p"Failed\n",__func__,__LINE__);\
	return (ret);}
#define SAFE_FREE(p) if(p != NULL){free(p); p = NULL;}

#ifdef __cplusplus
}
#endif

#endif


personbuilder.h

#ifndef __PERSONBUILDER_H__
#define __PERSONBUILDER_H__

#include "typedef.h"

#ifdef __cplusplus
extern "C" {
#endif

enum PersonSize
{
    P_WIDTH = 21,
    P_HEIGHT = 12
};

struct _PersonBuilder;
typedef struct _PersonBuilder PersonBuilder;

struct _PersonBuilder
{
	char element[P_HEIGHT][P_WIDTH];
	void (*build_head)(void *pPersonBuilder);
	void (*build_body)(void *pPersonBuilder);
	void (*build_arm_left)(void *pPersonBuilder);
	void (*build_arm_right)(void *pPersonBuilder);
	void (*build_leg_left)(void *pPersonBuilder);
	void (*build_leg_right)(void *pPersonBuilder);
	void (*person_display)(void *pPersonBuilder);
	void (*destroy)(void *pBuilder);
};

static inline void build_head(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->build_head != NULL)
	{
		thiz->build_head(thiz);
	}
}

static inline void build_body(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->build_body != NULL)
	{
		thiz->build_body(thiz);
	}
}

static inline void build_arm_left(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->build_arm_left != NULL)
	{
		thiz->build_arm_left(thiz);
	}
}

static inline void build_arm_right(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->build_arm_right != NULL)
	{
		thiz->build_arm_right(thiz);
	}
}

static inline void build_leg_left(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->build_leg_left != NULL)
	{
		thiz->build_leg_left(thiz);
	}
}

static inline void build_leg_right(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->build_leg_right != NULL)
	{
		thiz->build_leg_right(thiz);
	}
}

static inline void person_display(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->person_display != NULL)
	{
		thiz->person_display(thiz);
	}
}

static inline void person_destroy(PersonBuilder *thiz)
{
	return_if_fail(thiz != NULL);

	if(thiz->destroy != NULL)
	{
		thiz->destroy(thiz);
	}
}





#ifdef __cplusplus
}
#endif

#endif


thinbuilder.h

#ifndef __THINBUILDER_H__
#define __THINBUILDER_H__

#include "personbuilder.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _ThinBuilder;
typedef struct _ThinBuilder ThinBuilder;

struct _ThinBuilder
{
	PersonBuilder person;
};

ThinBuilder *thin_builder_create(void);

#ifdef __cplusplus
}
#endif

#endif


thinbuilder.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "thinbuilder.h"

static void thin_build_head(void *pThinBuilder)
{
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[0], "                    ");
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[1], "        |~~|        ");
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[2], "        |__|        ");
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[3], "         ||         ");
}

static void thin_build_body(void *pThinBuilder)
{
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[4], "        |~~|        ");
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[5], "        |  |        ");
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[6], "        |  |        ");
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[7], "        |__|        ");    
}

static void thin_build_arm_left(void *pThinBuilder)
{    
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[4], "     ||-", 8);
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[5], "     || ", 8);
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[6], "     || ", 8);
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[7], "     || ", 8);
}

static void thin_build_arm_right(void *pThinBuilder)
{
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[4] + 12, "-||", 3);
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[5] + 12, " ||", 3);
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[6] + 12, " ||", 3);
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[7] + 12, " ||", 3);
}

static void thin_build_leg_left(void *pThinBuilder)
{     
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[8], "        //", 10);  
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[9], "       // ", 10);  
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[10], "      //  ", 10);  
    strncpy(((ThinBuilder *)pThinBuilder)->person.element[11], "     //   ", 10);  
}

static void thin_build_leg_right(void *pThinBuilder)
{
    
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[8] + 10, "\\\\        ");  
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[9] + 10, " \\\\       ");  
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[10] + 10, "  \\\\      ");  
    strcpy(((ThinBuilder *)pThinBuilder)->person.element[11] + 10, "   \\\\     "); 
}

static void thin_display(void *pThinBuilder)
{
    ThinBuilder *temp = pThinBuilder;
    int i;
    for(i = 0; i < P_HEIGHT; i++)
    {
        printf(" %s\n", temp->person.element[i]);
    }
}

static void thin_destroy(void *thiz)
{
	if(thiz != NULL)
	{
		SAFE_FREE(thiz);
	}
}


ThinBuilder *thin_builder_create(void)
{
	ThinBuilder *thiz = malloc(sizeof(ThinBuilder));

	if(thiz != NULL)
	{
		thiz->person.build_head = thin_build_head;
		thiz->person.build_body = thin_build_body;
		thiz->person.build_arm_left = thin_build_arm_left;
		thiz->person.build_arm_right = thin_build_arm_right;
		thiz->person.build_leg_left = thin_build_leg_left;
		thiz->person.build_leg_right = thin_build_leg_right;
		thiz->person.person_display = thin_display;
		thiz->person.destroy = thin_destroy;
	}

	return thiz;
}


fatbuilder.h

#ifndef __FATBUILDER_H__
#define __FATBUILDER_H__

#include "personbuilder.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _FatBuilder;
typedef struct _FatBuilder FatBuilder;

struct _FatBuilder
{
	PersonBuilder person;
};

FatBuilder *fat_builder_create(void);

#ifdef __cplusplus
}
#endif

#endif


fatbuilder.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "fatbuilder.h"

static void fat_build_head(void *pFatBuilder)
{
    strcpy(((FatBuilder *)pFatBuilder)->person.element[0], "                    ");
    strcpy(((FatBuilder *)pFatBuilder)->person.element[1], "       |~~~~|       ");
    strcpy(((FatBuilder *)pFatBuilder)->person.element[2], "       |____|       ");
    strcpy(((FatBuilder *)pFatBuilder)->person.element[3], "        |  |        ");
}

static void fat_build_body(void *pFatBuilder)
{
    strcpy(((FatBuilder *)pFatBuilder)->person.element[4], "       |~~~~|       ");
    strcpy(((FatBuilder *)pFatBuilder)->person.element[5], "       |    |       ");
    strcpy(((FatBuilder *)pFatBuilder)->person.element[6], "       |    |       ");
    strcpy(((FatBuilder *)pFatBuilder)->person.element[7], "       |____|       ");    
}

static void fat_build_arm_left(void *pFatBuilder)
{    
    strncpy(((FatBuilder *)pFatBuilder)->person.element[4], "   |~|~", 7);
    strncpy(((FatBuilder *)pFatBuilder)->person.element[5], "   | | ", 7);
    strncpy(((FatBuilder *)pFatBuilder)->person.element[6], "   | | ", 7);
    strncpy(((FatBuilder *)pFatBuilder)->person.element[7], "   | | ", 7);
}

static void fat_build_arm_right(void *pFatBuilder)
{
    strncpy(((FatBuilder *)pFatBuilder)->person.element[4] + 13, "~|~|", 4);
    strncpy(((FatBuilder *)pFatBuilder)->person.element[5] + 13, " | |", 4);
    strncpy(((FatBuilder *)pFatBuilder)->person.element[6] + 13, " | |", 4);
    strncpy(((FatBuilder *)pFatBuilder)->person.element[7] + 13, " | |", 4);
}

static void fat_build_leg_left(void *pFatBuilder)
{     
    strncpy(((FatBuilder *)pFatBuilder)->person.element[8], "       / /", 10);  
    strncpy(((FatBuilder *)pFatBuilder)->person.element[9], "      / / ", 10);  
    strncpy(((FatBuilder *)pFatBuilder)->person.element[10], "     / /  ", 10);  
    strncpy(((FatBuilder *)pFatBuilder)->person.element[11], "    / /   ", 10);  
}

static void fat_build_leg_right(void *pFatBuilder)
{
    
    strcpy(((FatBuilder *)pFatBuilder)->person.element[8] + 10, "\\ \\       ");  
    strcpy(((FatBuilder *)pFatBuilder)->person.element[9] + 10, " \\ \\      ");  
    strcpy(((FatBuilder *)pFatBuilder)->person.element[10] + 10, "  \\ \\     ");  
    strcpy(((FatBuilder *)pFatBuilder)->person.element[11] + 10, "   \\ \\    "); 
}

static void fat_display(void *pFatBuilder)
{
    FatBuilder *temp = pFatBuilder;
    int i;
    for(i = 0; i < P_HEIGHT; i++)
    {
        printf(" %s\n", temp->person.element[i]);
    }
}

static void fat_destroy(void *thiz)
{
	if(thiz != NULL)
	{
		SAFE_FREE(thiz);
	}
}

FatBuilder *fat_builder_create(void)
{
	FatBuilder *thiz = malloc(sizeof(FatBuilder));

	if(thiz != NULL)
	{
		thiz->person.build_head = fat_build_head;
		thiz->person.build_body = fat_build_body;
		thiz->person.build_arm_left = fat_build_arm_left;
		thiz->person.build_arm_right = fat_build_arm_right;
		thiz->person.build_leg_left = fat_build_leg_left;
		thiz->person.build_leg_right = fat_build_leg_right;
		thiz->person.person_display = fat_display;
		thiz->person.destroy = fat_destroy;
	}

	return thiz;
}


builderclient.h

#ifndef __BUILDERCLIENT_H__
#define __BUILDERCLIENT_H__

#include "personbuilder.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _BuilderClient;
typedef struct _BuilderClient BuilderClient;

struct _BuilderClient
{
	PersonBuilder *builder;
};

void set_builder(BuilderClient *thiz, PersonBuilder *builder);
void person_create(BuilderClient *thiz);

#ifdef __cplusplus
}
#endif

#endif


builderclient.c

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

void set_builder(BuilderClient *thiz, PersonBuilder *builder)
{
	thiz->builder = builder;
	return ;
}

void person_create(BuilderClient *thiz)
{
	return_if_fail(thiz != NULL);

	thiz->builder->build_head(thiz->builder);
	thiz->builder->build_body(thiz->builder);
	thiz->builder->build_arm_left(thiz->builder);
	thiz->builder->build_arm_right(thiz->builder);
	thiz->builder->build_leg_left(thiz->builder);
	thiz->builder->build_leg_right(thiz->builder);
}


test.c

#include <stdio.h>
#include <stdlib.h>
#include "builderclient.h"
#include "thinbuilder.h"
#include "fatbuilder.h"

int main(int argc, char **argv)
{
	BuilderClient *client = malloc(sizeof(BuilderClient));
	PersonBuilder *builder = (PersonBuilder *)thin_builder_create();
	set_builder(client, builder);
	person_create(client);
	person_display(builder);
	person_destroy(builder);

	return 0;
}


Makefile

exe:=test
temp := $(wildcard test *~) 

all:test.c personbuilder.h thinbuilder.h thinbuilder.c fatbuilder.h fatbuilder.c builderclient.h builderclient.c typedef.h
	gcc -g $^ -o $(exe)

clean:
	rm $(temp)


 

【源码下载】

 

 

*欢迎纠错，共同进步！

 

转载请标明出处，仅供学习交流，勿用于商业目的

Copyright @ http://blog.youkuaiyun.com/tandesir

数学建模 用C语言实现
11-06
I显示方法 埃特肯 杜氏分解法 二分法 分段线性插值 复合梯形法、复合辛普森、改进欧拉法 高斯消去法 如何用C语言语言实现
C语言实现设计模式.zip
06-13
当我们谈论"C语言实现设计模式"时，我们关注的是如何在C这种静态类型、过程式编程语言中应用面向对象的设计原则和最佳实践。C语言虽然不具备像Java或C++那样的内置面向对象特性，但通过巧妙的技巧和结构，我们仍然...
C语言和设计模式（建造者模式）
嵌入式-老费，一个分享专业嵌入式知识的blog
01-01 9450
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     如果说前面的工厂模式是对接口进行抽象化处理，那么建造者模式更像是对流程本身的一种抽象化处理。这话怎么理解呢？大家可以听我慢慢到来。以前买电脑的时候，大家都喜欢自己组装机器。一方面可以满足自己的个性化需求，另外一方面也可以在价格上得到很多实惠。但是电脑是由很多部分组成的，每个厂家都
C语言：建造者模式
一鸣惊人的博客
02-08 570
构建者模式是一种常见的创建型设计模式，此模式基于分而治之的理念将产品的构建算法和产品的组件和组装分离，从而实质彼此的独立变化。所以相同的构建算法可以根据不同的部件及组装创建出不同的产品，不同的创建算法亦可以复用相同的组件及组装从而创建不同的产品。
设计模式之建造者模式
1024350154--lj博客
08-20 352
（一）概念： Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。 对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对
C语言设计模式--建设者模式(C语言案例)
m0_38056437的博客
04-09 300
前言 这里先插一点题外话，在C语言中，实现封装、继承、隐藏、多态等等特性，是完全没有问题的。但是在使用过程中，必定是不如自带这些特性的语言方便好用的，比如C++\java等。 一旦要通过C语言来实现各种设计模式，必定会在严谨地维护类层次上造成非常繁琐和臃肿的代码。这是因为C++/java等自带一套面向对象的工具，而C语言要在代码设计中，不断地根据实际情况来创造面向对象的工具。 更多深层次的原...
C语言设计模式 PDF《C Design Pattern》
04-17
在C中，可以通过定义建造者结构体和相应的建造函数来实现这一模式。 ```c typedef struct Builder Builder; typedef struct Product Product; struct Builder { void (*build_part_a)(Product*); void (*build_...
C语言-设计模式汇总，包含23中常见设计模式，利用C语言实现；
10-10
设计模式分为三大类：创建型模式（如工厂模式、建造者模式、抽象工厂模式）、结构型模式（如适配器模式、桥接模式、装饰器模式、组合模式、外观模式、享元模式、代理模式）和行为型模式（如观察者模式、模板方法模式...
使用C语言实现23种设计模式。.zip
最新发布
06-14
这个压缩包“使用C语言实现23种设计模式”可能包含了将经典的Java或C++设计模式转换为C语言形式的示例代码。 23种设计模式主要分为三大类：创建型、结构型和行为型。 1. 创建型设计模式： - 单例模式：确保一个类...
C语言实现设计模式探索
设计模式包括单件模式、工厂模式、抽象工厂模式、访问者模式、状态模式、命令模式、解释器模式、备忘录模式、观察者模式、桥接模式、建造者模式、中介者模式、策略模式、适配器模式、装饰模式、亨元模式、代理模式、...
C程序设计五百例--用c语言解决数学建模问题
05-26
C程序设计五百例--用c语言解决数学建模问题，要用数学建模的同学们可以下载使用，提高自己的C语言编程能力
C语言设计模式
02-06
$ ls 备忘录模式.pdf 工厂模式.pdf 模板模式.pdf 中介者模式.pdf 策略模式.pdf 观察者模式.pdf 桥接模式.pdf 装饰模式.pdf 抽象工厂模式.pdf 继承、封装、多态.pdf 适配器模式.pdf 状态模式.pdf 代理模式.pdf 建造者模式.pdf 外观模式.pdf 组合模式.pdf 单件模式.pdf 解释器模式.pdf 享元模式.pdf 迭代器模式.pdf 开篇.pdf 原型模式.pdf 访问者模式.pdf 命令模式.pdf 责任链模式.pdf $ http://blog.youkuaiyun.com/feixiaoxing/article/category/951264的mirror
设计模式的C语言应用-建造者模式-第七章
华为云官方博客
07-16 1731
模式介绍 建造者模式将复杂产品的构建过程封装分解在不同的方法中，使得创建过程非常清晰。它隔离了复杂产品对象的创建和使用，使得相同的创建过程能够创建不同的产品。若几个产品之间存在较大的差异，则不适用建造者模式 面向对象里的建造者模式，对于C语言，就无需这么复杂了。 比如用C构建一个网络数据包，需要构建Dmac域，smac域，长度域，IP等各层头。如果代码写在一个函数里，那么会很长很复杂...
设计模式之建造者模式（C语言）
Hongggggggg
12-27 903
介绍： ​ 建造者模式是一种创建型设计模式，亦称创建者模式、生成器模式等；该模式是将一个复杂的对象分解为许多简单的对象，然后逐步构建出想要的产品，产品的最终形态都是一致的，但是具体组成的每个对象可能是不相同的； 优点： 将复杂对象的构建与表示分离； 只需要选择具体的组成对象即可创建出复杂的对象，无需知道建造细节； 类比： ​ 一个台式机是由CPU、显卡、内存、硬盘等部件组成，我们可以根据自己的需求选择不同型号不同厂商的部件，比如说CPU选择Intel或者AMD的；在这里一个台式机就是由需多部件组成，
C 语言计算机运行模型
zhrq95的博客
03-22 654
操作系统专门在内存里开一个区域来存放代码指令（代码段），每一个函数，都有一个代码段。程序运行时代码段是只读的。CPU 根据一个指令指针来取当前指令，执行完后，指令指针移动到下一条指令（顺序执行），或跳转到指定的指令（条件、循环）要点：1、每个函数是一个独立的代码片段，在代码段中；2、有一个指令指针，来决定当前 CPU 执行的指令。return 语句的两个功能：1、将指令指针拨回到调用函数的下一条指...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值