简单工厂模式(大话设计模式)C/C++版本

已于 2024-07-10 15:48:00 修改
阅读量334 收藏
点赞数 2
分类专栏： 设计模式 文章标签： 简单工厂模式 设计模式 c语言
于 2024-06-13 19:45:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47104421/article/details/139662826
版权

简单工厂模式

在这里插入图片描述

  1. 加减乘除共有部分，形成基类
  2. 简单工厂类"知道"运算类，但是不构成has-a和contains-a的语义，所以是关联。

计算器
1. input number => 易变(界面逻辑)
2. select operator => 运算符类(业务逻辑)
3. calculate => 不同运算对应不同计算方法(业务逻辑)
4. outupt result(界面逻辑)

界面输入到业务的过程 => 工厂类
2+3 => 运算类
==>
1. 业务逻辑与界面逻辑分离 => 将计算过程封装成函数 封装
2. 不同的运算符对应的不同的计算过程分离成类 => 继承共有特性 继承
3. 各运算符实现基类中的GetResult => 重写共有行为 多态

将界面逻辑的输入到业务逻辑的地方，封装成一个函数也是不错的。但是将其用类来封装更好。
类封装较于函数封装的好处：
1. 类：属性+行为；函数：行为
2. 类支持继承，更易于扩展(较于函数可以随便加属性和新的行为)
3. 封装性更好（作用域就更安全更小）
4. 面向对象编程，更有连续性，创建一个类实例后，多次使用的都是同一个实例的方法；
而函数多次调用后，连续和联系没有那么强，少了点OOP的味儿~

C++版本

参考：https://www.cnblogs.com/Galesaur-wcy/p/15926669.html

#include <iostream>
using namespace std;
// 运算类
class Operation
{
private:
	double _NumA;
	double _NumB;

public:
	void SetNumA()
	{
		cout << "Enter a double number: ";
		if (!(cin >> _NumA))
			throw "It must be a number";
	}

	double GetNumA()
	{
		return _NumA;
	}

	void SetNumB()
	{
		cout << "Enter a double number: ";
		if (!(cin >> _NumB))
			throw "It must be a number";
	}

	double GetNumB()
	{
		return _NumB;
	}

	virtual double GetResult()
	{
		int result = 0;
		return result;
	}
};

class OperationAdd : public Operation
{
public:
	double GetResult()
	{
		double result = GetNumA() + GetNumB();
		return result;
	}
};

class OperationSub : public Operation
{
public:
	double GetResult()
	{
		double result = GetNumA() - GetNumB();
		return result;
	}
};

class OperationMul : public Operation
{
public:
	double GetResult()
	{
		double result = GetNumA() * GetNumB();
		return result;
	}
};

class OperationDiv : public Operation
{
public:
	double GetResult()
	{
		if (GetNumB() == 0)
		{
			throw "The divisor cannot be 0";
		}
		double result = GetNumA() / GetNumB();
		return result;
	}
};

class OperatorFactory
{
public:
	Operation *CreatOperation(char s)
	{
		Operation *ope = nullptr;
		switch (s)
		{
		case '+':
			ope = new OperationAdd;
			break;
		case '-':
			ope = new OperationSub;
			break;
		case '*':
			ope = new OperationMul;
			break;
		case '/':
			ope = new OperationDiv;
			break;
		default:
			throw "Error input operator!";
			break;
		}
		return ope;
	}
};

int main()
{
	OperatorFactory fac;
	cout << "Choose an operation:";
	char operator_char;
	cin >> operator_char;
	try
	{
		Operation *oper = fac.CreatOperation(operator_char);
		oper->SetNumA();
		oper->SetNumB();
		cout << "result is: " << oper->GetResult() << endl;
	}
	catch (const char *err)
	{
		cerr << err << endl;
		return -1;
	}

	return 0;
}

C版本

C底层是不支持面向对象编程的(如：继承、多态)，但是不是说不可以面向对象编程的。
C的结构体就是最类似class类的概念，但是不支持行为属性，只能通过回调函数，依赖倒置，将实现交给开发者。但是这也说明C中的对象的行为不是生来就有的，是需要初始化的。而且该行为的作用域也比类中行为的要大。

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

typedef struct Operation
{
    double NumA;
    double NumB;
    double (*GetResult)(struct Operation *);
} Operation;

typedef struct OperationAdd
{
    Operation base; // 设置为第一个成员属性，模拟继承
} OperationAdd;

typedef struct OperationSub
{
    Operation base;
} OperationSub;

typedef struct OperationMul
{
    Operation base;
} OperationMul;

typedef struct OperationDiv
{
    Operation base;
} OperationDiv;

double OperationAddGetResult(struct Operation *op)
{
    OperationAdd *add = (OperationAdd *)op;
    return add->base.NumA + add->base.NumB;
}

double OperationSubGetResult(struct Operation *op)
{
    OperationSub *sub = (OperationSub *)op;
    return sub->base.NumA - sub->base.NumB;
}

double OperationMulGetResult(struct Operation *op)
{
    OperationMul *mul = (OperationMul *)op;
    return mul->base.NumA * mul->base.NumB;
}

double OperationDivGetResult(struct Operation *op)
{
    OperationDiv *div = (OperationDiv *)op;
    if (div->base.NumB == 0)
    {
        fputs("The divisor cannot be 0\n", stderr);
        exit(EXIT_FAILURE);
    }
    return div->base.NumA / div->base.NumB;
}

Operation *CreateOperation(char op)
{
    Operation *ope = NULL;
    switch (op)
    {
    case '+':
        ope = malloc(sizeof(OperationAdd));
        ope->GetResult = OperationAddGetResult;
        break;
    case '-':
        ope = malloc(sizeof(OperationSub));
        ope->GetResult = OperationSubGetResult;
        break;
    case '*':
        ope = malloc(sizeof(OperationMul));
        ope->GetResult = OperationMulGetResult;
        break;
    case '/':
        ope = malloc(sizeof(OperationDiv));
        ope->GetResult = OperationDivGetResult;
        break;
    default:
        fputs("Error input operator!\n", stderr);
        return NULL;
    }
    return ope;
}

void SetNumA(Operation *ope)
{
    printf("Enter a double number: ");
    if (scanf("%lf", &ope->NumA) != 1)
    {
        fputs("It must be a number\n", stderr);
        exit(EXIT_FAILURE);
    }
}

void SetNumB(Operation *ope)
{
    printf("Enter a double number: ");
    if (scanf("%lf", &ope->NumB) != 1)
    {
        fputs("It must be a number\n", stderr);
        exit(EXIT_FAILURE);
    }
}

int main()
{
    printf("Choose an operation: ");
    char operator_char = getchar();

    Operation *oper = CreateOperation(operator_char);
    if (!oper)
        return EXIT_FAILURE;

    SetNumA(oper);
    SetNumB(oper);
    printf("Result is: %f\n", oper->GetResult(oper));

    free(oper);
    return 0;
}

在前一版的基础上，将SetNumA和SetNumB设置为Operation类（结构体）的行为，代码如下：

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

typedef struct Operation
{
    double NumA;
    double NumB;
    double (*GetResult)(struct Operation *);
    void (*SetNumA)(struct Operation *);
    void (*SetNumB)(struct Operation *);
} Operation;

typedef struct OperationAdd
{
    Operation base; // 设置为第一个成员属性，模拟继承
} OperationAdd;

typedef struct OperationSub
{
    Operation base;
} OperationSub;

typedef struct OperationMul
{
    Operation base;
} OperationMul;

typedef struct OperationDiv
{
    Operation base;
} OperationDiv;

double OperationAddGetResult(struct Operation *op)
{
    OperationAdd *add = (OperationAdd *)op;
    return add->base.NumA + add->base.NumB;
}

double OperationSubGetResult(struct Operation *op)
{
    OperationSub *sub = (OperationSub *)op;
    return sub->base.NumA - sub->base.NumB;
}

double OperationMulGetResult(struct Operation *op)
{
    OperationMul *mul = (OperationMul *)op;
    return mul->base.NumA * mul->base.NumB;
}

double OperationDivGetResult(struct Operation *op)
{
    OperationDiv *div = (OperationDiv *)op;
    if (div->base.NumB == 0)
    {
        fputs("The divisor cannot be 0\n", stderr);
        exit(EXIT_FAILURE);
    }
    return div->base.NumA / div->base.NumB;
}

void SetNumA(Operation *ope)
{
    printf("Enter a double number: ");
    if (scanf("%lf", &ope->NumA) != 1)
    {
        fputs("It must be a number\n", stderr);
        exit(EXIT_FAILURE);
    }
}

void SetNumB(Operation *ope)
{
    printf("Enter a double number: ");
    if (scanf("%lf", &ope->NumB) != 1)
    {
        fputs("It must be a number\n", stderr);
        exit(EXIT_FAILURE);
    }
}

Operation *CreateOperation(char op)
{
    Operation *ope = NULL;
    switch (op)
    {
    case '+':
        ope = malloc(sizeof(OperationAdd));
        ope->GetResult = OperationAddGetResult;
        break;
    case '-':
        ope = malloc(sizeof(OperationSub));
        ope->GetResult = OperationSubGetResult;
        break;
    case '*':
        ope = malloc(sizeof(OperationMul));
        ope->GetResult = OperationMulGetResult;
        break;
    case '/':
        ope = malloc(sizeof(OperationDiv));
        ope->GetResult = OperationDivGetResult;
        break;
    default:
        fputs("Error input operator!\n", stderr);
        return NULL;
    }
    ope->SetNumA = SetNumA;
    ope->SetNumB = SetNumB;
    return ope;
}

int main()
{
    printf("Choose an operation: ");
    char operator_char = getchar();

    Operation *oper = CreateOperation(operator_char);
    if (!oper)
        return EXIT_FAILURE;

    oper->SetNumA(oper);
    oper->SetNumB(oper);
    printf("Result is: %f\n", oper->GetResult(oper));

    free(oper);
    return 0;
}
没有理想的不伤心
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
C++设计模式之建造者模式
01-20
建造者模式 在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的...在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为
《大话设计模式》C++实现：01 简单工厂模式
qq_29567701的博客
08-21 329
文章目录1. 什么是简单工厂模式？2. 简单工厂模式的适用场景？2.1 优点2.2 缺点3. 怎样使用简单工厂模式？3.1 方法3.2 UML类图4. 实例4.1 结果（结论先行）4.2 具体实现4.2.1 操作符集成体系代码4.2.2 简单工厂的静态接口 1. 什么是简单工厂模式？ 当出现批量化的产品时，使用单独的类创建每个产品，实现去实例化对象。 2. 简单工厂模式的适用场景？ 2.1 优点 1、降低了客户与具体实现的耦合（相较不使用简单工厂而言）。 封装了细节，客户只需调用工厂接口，不必关心如何创建产
工厂方法模式(大话设计模式)C/C++版本
m0_47104421的博客
06-14 415
参考：https://www.cnblogs.com/Galesaur-wcy/p/15926711.html。
抽象工厂模式(大话设计模式)C/C++版本
m0_47104421的博客
06-15 515
在工厂方法模式的基础上，在对应的工厂类中新增了相关产品的创建函数。（其实并不是很方便！！扩展：简单工厂模式似乎更简便点，但是switch部分实在是破坏了开闭原则，可以使用“反射”（即动态识别类型）C++可以使用静态函数指针数组来实现参考：https://blog.csdn.net/klarclm/article/details/7352101。
装饰模式(大话设计模式)C/C++版本
m0_47104421的博客
07-13 698
将Person类中一大堆服饰功能抽象出服饰类，然后通过Person类聚合服饰属性，通过Set行为来设置服饰属性，最后达到灵活打扮的效果装饰模式动态地给一个对象添加一些额外的职责，就增加功能来说 装饰模式比生成子类更为灵活1. 装饰对象的实现和如何使用该对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。2. 装饰模式是结构性的模式，将所需要的功能按正确的顺序串联起来进行控制。
模板方法模式(大话设计模式)C/C++版本
m0_47104421的博客
06-14 289
设计基类的时候，最大程度上的去复用代码，尽可能的泛化。细节高层次的差别的地方可以virtual，要求子类重写。
策略模式(大话设计模式)C/C++版本
m0_47104421的博客
07-11 323
商场收银软件根据客户所购买商品的单价和数量来收费。
组合模式(大话设计模式)C/C++版本
m0_47104421的博客
07-08 304
【代码】组合模式(大话设计模式)C/C++版本。
代理模式(大话设计模式)C/C++版本
m0_47104421的博客
07-13 465
【代码】代理模式(大话设计模式)C/C++版本。
桥接模式(大话设计模式)C/C++版本
m0_47104421的博客
07-08 356
【代码】桥接模式(大话设计模式)C/C++版本。
【代码洁癖症】第1回-简单工厂模式
12-22
在一个宁静的午后，我有幸拜读了程杰大鸟的《大话设计模式》 觉得这是一本不可多得的好书 奈何里面都是C++代码写的示例，对于学Java的同学不是很友好 于是想将书中的核心提炼出来并结合Java示例与大家分享 并且加入...
读书笔记：《大话设计模式》C++实现.zip
最新发布
07-23
读书笔记：《大话设计模式》C++实现
读书笔记：《大话设计模式》C++代码实现.zip
07-23
读书笔记：《大话设计模式》C++代码实现
简单工厂模式
weixin_51803498的博客
07-19 442
在这个例子中，ShapeFactory 类是一个简单工厂，它根据传入的字符串来决定创建哪个形状对象。注意，简单工厂模式的一个主要缺点是，每当有新的形状类被添加到系统中时，ShapeFactory 类也需要被修改，这违反了开闭原则（对扩展开放，对修改关闭）。在简单工厂模式中，我们创建一个工厂类，这个类用于根据传入的信息动态决定应该创建哪一个类的实例。在这个例子中，我们将创建一个形状工厂，它能够基于传入的类型信息来创建不同类型的形状对象（如圆形、矩形等）。然后，创建实现该接口的具体类，例如。
简单工厂模式、工厂模式和抽象工厂模式的区别
weixin_51803498的博客
07-19 753
简单工厂模式（Simple Factory Pattern）简单工厂模式又称为静态工厂方法模式，是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。提供一个创建对象的接口，客户端通过调用工厂类的静态方法来获取对象实例，而无需关心对象的具体创建过程。工厂模式（Factory Method Pattern）工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到其子类进行。
iOS开发设计模式篇第一篇MVC设计模式
我叫柱子哥
07-22 624
MVC（Model-View-Controller）是一种常见的软件设计模式，旨在将应用程序的逻辑、用户界面和输入进行分离。在iOS开发中，MVC帮助开发者组织代码，提高可维护性和可扩展性，使得项目结构更加清晰。本文将介绍MVC的基本概念、在iOS中的具体实现、优缺点、实践建议，以及其他常见的架构模式。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 587
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
大话设计模式 c++
09-13
其中创建型模式包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式；结构型模式包括适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式和享元模式；行为型模式包括策略...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值