建造模式C语言实现

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

【说明】建造模式的C语言实现，改写自http://blog.csdn.net/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.csdn.net/tandesir

tandesir
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数学建模 用C语言实现
11-06
I显示方法 埃特肯 杜氏分解法 二分法 分段线性插值 复合梯形法、复合辛普森、改进欧拉法 高斯消去法 如何用C语言语言实现
C语言和设计模式（建造者模式）
嵌入式-老费，一个分享专业嵌入式知识的blog
01-01 9217
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     如果说前面的工厂模式是对接口进行抽象化处理，那么建造者模式更像是对流程本身的一种抽象化处理。这话怎么理解呢？大家可以听我慢慢到来。以前买电脑的时候，大家都喜欢自己组装机器。一方面可以满足自己的个性化需求，另外一方面也可以在价格上得到很多实惠。但是电脑是由很多部分组成的，每个厂家都
C语言：建造者模式
一鸣惊人的博客
02-08 460
构建者模式是一种常见的创建型设计模式，此模式基于分而治之的理念将产品的构建算法和产品的组件和组装分离，从而实质彼此的独立变化。所以相同的构建算法可以根据不同的部件及组装创建出不同的产品，不同的创建算法亦可以复用相同的组件及组装从而创建不同的产品。
设计模式之建造者模式
1024350154--lj博客
08-20 292
（一）概念： Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。 对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对
C语言设计模式--建设者模式(C语言案例)
m0_38056437的博客
04-09 265
前言 这里先插一点题外话，在C语言中，实现封装、继承、隐藏、多态等等特性，是完全没有问题的。但是在使用过程中，必定是不如自带这些特性的语言方便好用的，比如C++\java等。 一旦要通过C语言来实现各种设计模式，必定会在严谨地维护类层次上造成非常繁琐和臃肿的代码。这是因为C++/java等自带一套面向对象的工具，而C语言要在代码设计中，不断地根据实际情况来创造面向对象的工具。 更多深层次的原...
工厂方法模式的C语言实现
03-05
工厂方法模式的C语言实现。改写自http://blog.csdn.net/sx_wpc/article/details/7645062一文的代码。
简单工厂模式C语言实现
03-05
简单工厂模式C语言实现，改写自http://blog.csdn.net/sx_wpc/article/details/7645062一文的代码。
C语言实现的websocket
11-18
该资源用C语言实现的简易websocket测试程序，并附有web端的html页面辅助调试，供websocket学习者下载使用，理解websocket协议
C语言实现的数字滤波器
最新发布
11-16
数字滤波器，用c语言书写实现，包含低通、高通、带通等
C语言实现 队列
11-24
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.csdn.net/feixiaoxing/article/category/951264的mirror
设计模式的C语言应用-建造者模式-第七章
华为云官方博客
07-16 1478
模式介绍 建造者模式将复杂产品的构建过程封装分解在不同的方法中，使得创建过程非常清晰。它隔离了复杂产品对象的创建和使用，使得相同的创建过程能够创建不同的产品。若几个产品之间存在较大的差异，则不适用建造者模式 面向对象里的建造者模式，对于C语言，就无需这么复杂了。 比如用C构建一个网络数据包，需要构建Dmac域，smac域，长度域，IP等各层头。如果代码写在一个函数里，那么会很长很复杂...
c语言变量建模,C语言内存四驱模型
weixin_29063681的博客
05-18 211
一、数据类型的本质1、数据类型可以理解为创建变量的模具，是固定内存大小的别名。2、数据类型的作用：编译器预算对象(变量)分配内存空间大小二、void1)、void简介void 的字面意思是“无类型”，void*则为“无类型指针”，void *可以指向任何数据类型。在c中不存在void类型的变量，因为c语言就没有定义void究竟是多大内存的别名。c语言中void有两种使用方式：1、用于修饰函数的返回...
设计模式之建造者模式（C语言）
Hongggggggg
12-27 807
介绍： ​ 建造者模式是一种创建型设计模式，亦称创建者模式、生成器模式等；该模式是将一个复杂的对象分解为许多简单的对象，然后逐步构建出想要的产品，产品的最终形态都是一致的，但是具体组成的每个对象可能是不相同的； 优点： 将复杂对象的构建与表示分离； 只需要选择具体的组成对象即可创建出复杂的对象，无需知道建造细节； 类比： ​ 一个台式机是由CPU、显卡、内存、硬盘等部件组成，我们可以根据自己的需求选择不同型号不同厂商的部件，比如说CPU选择Intel或者AMD的；在这里一个台式机就是由需多部件组成，
aes-gcm工作模式 c语言实现
05-12
实现AES-GCM工作模式可以使用C语言进行开发。 要实现AES-GCM工作模式，首先需要使用C语言中的AES加密算法实现数据加密。然后，需要使用GCM身份验证方法计算附加身份验证数据（AD）和明文的身份验证标签（TAG）。GCM...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值