「C++ 篇」答应我,别再if/else走天下了可以吗
2020-02-15 16:00:48来源:博客园 阅读 ()
「C++ 篇」答应我,别再if/else走天下了可以吗
每日一句英语学习,每天进步一点点:
- "Without purpose, the days would have ended, as such days always end, in disintegration."
- 「少了目标,一天还是会结束,它总是以支离破碎的形式结束。」
前言
羊哥之前写一篇有趣的文章《答应我,别再if/else走天下了可以吗 | CodeSheep 》,在文中使用 Java 语言实现了枚举类、工厂模式和策略模式的三种方式,来消除连环的 if / else
。内容层层递进,由浅入深的方式我非常喜欢。
看到有留言中有小伙伴想看 C++ 版本的,特此写下了此文(已经过羊哥的同意)。不过由于 C++ 没有枚举类,所以本文不涉及此方式,但本文会带大家一步一步的优化工厂模式和策略模式。
正文
糟糕 if / else 连环
if / else
可以说是我们学习编程时,第一个学习的分支语句,简单易理解,生活中也处处有的 if / else
例子:
老婆给当程序员的老公打电话:“下班顺路买一斤包子带回来,如果看到卖西瓜的,买一个。”
当晚,程序员老公手捧一个包子进了家门。。。
老婆怒道:“你怎么就买了一个包子?!”
老公答曰:“因为看到了卖西瓜的。”
老婆的思维:
买一斤包子; if( 看到卖西瓜的 ) 买一只( 西瓜 );
而程序员老公的程序:
if( ! 看见卖西瓜的 ) 买一斤包子; else 买一只( 包子 );
非常生生动动的生活例子!如果身为程序员的你,犯了同样的思维错误,别继续问你媳妇为什么,问就是跪键盘:
进入本文正题。考虑以下栗子:一般来说我们正常的后台管理系统都有所谓的角色的概念,不同管理员权限不一样,能够行使的操作也不一样。
- 系统管理员(
ROLE_ROOT_ADMIN
):有A
操作权限 - 订单管理员(
ROLE_ORDER_ADMIN
):有B
操作权限 - 普通用户(
ROLE_NORMAL
):有C
操作权限
假设一个用户进来,我们需要根据不同用户的角色来判断其有哪些行为。使用过多 if / else
连环写法的我们,肯定下意识就觉得,这不简单嘛,我上演一套连环的写法:
class JudgeRole { public: std::string Judge( std::string roleName ) { std::string result = ""; if( roleName == "ROLE_ROOT_ADMIN" ) // 系统管理员 { result = roleName + "has A permission"; } else if( roleName == "ROLE_ORDER_ADMIN" ) // 订单管理员 { result = roleName + "has B permission"; } else if( roleName == "ROLE_NORMAL" ) // 普通用户 { result = roleName + "has C permission"; } return result; } };
当系统里有几十个角色,那岂不是几十个 if / else
嵌套,这个视觉效果绝对酸爽……这种实现方式非常的不优雅。
别人看了这种代码肯定大声喊:“我X,哪个水货写的!”
这时你听到,千万不要说:“那我改成 switch / case
”。千万别说,千万别说哦,否则可能拎包回家了…
因为 switch / case
和 if / else
毛区别都没,都是写费劲、难阅读、不易扩展的代码。
接下来简单讲几种改进方式,别再 if / else 走天下了。
工厂模式 —— 它不香吗?
不同的角色做不同的事情,很明显就提供了使用工厂模式的契机,我们只需要将不同情况单独定义好,并聚合到工厂里面即可。
首先,定义一个公用接口 RoleOperation
,类里有一个纯虚函数 Op
,供派生类(子类)具体实现:
// 基类 class RoleOperation { public: virtual std::string Op() = 0; // 纯虚函数 virtual ~RoleOperation() {} // 虚析构函数 };
接下来针对不同的角色类,继承基类,并实现 Op 函数:
// 系统管理员(有 A 操作权限) class RootAdminRole : public RoleOperation { public: RootAdminRole(const std::string &roleName) : m_RoleName(roleName) {} std::string Op() { return m_RoleName + " has A permission"; } private: std::string m_RoleName; }; // 订单管理员(有 B 操作权限) class OrderAdminRole : public RoleOperation { public: OrderAdminRole(const std::string &roleName) : m_RoleName(roleName) {} std::string Op() { return m_RoleName + " has B permission"; } private: std::string m_RoleName; }; // 普通用户(有 C 操作权限) class NormalRole : public RoleOperation { public: NormalRole(const std::string &roleName) : m_RoleName(roleName) {} std::string Op() { return m_RoleName + " has C permission"; } private: std::string m_RoleName; };
接下来在写一个工厂类 RoleFactory
,提供两个接口:
- 用以注册角色指针对象到工厂的
RegisterRole
成员函数 - 用以获取对应角色指针对象的
GetRole
成员函数
// 角色工厂 class RoleFactory { public: // 获取工厂单例,工厂的实例是唯一的 static RoleFactory& Instance() { static RoleFactory instance; // C++11 以上线程安全 return instance; } // 把指针对象注册到工厂 void RegisterRole(const std::string& name, RoleOperation* registrar) { m_RoleRegistry[name] = registrar; } // 根据名字name,获取对应的角色指针对象 RoleOperation* GetRole(const std::string& name) { std::map<std::string, RoleOperation*>::iterator it; // 从map找到已经注册过的角色,并返回角色指针对象 it = m_RoleRegistry.find(name); if (it != m_RoleRegistry.end()) { return it->second; } return nullptr; // 未注册该角色,则返回空指针 } private: // 禁止外部构造和虚构 RoleFactory() {} ~RoleFactory() {} // 禁止外部拷贝和赋值操作 RoleFactory(const RoleFactory &); const RoleFactory &operator=(const RoleFactory &); // 保存注册过的角色,key:角色名称 , value:角色指针对象 std::map<std::string, RoleOperation *> m_RoleRegistry; };
把所有的角色注册(聚合)到工厂里,并封装成角色初始化函数InitializeRole
:
void InitializeRole() // 初始化角色到工厂 { static bool bInitialized = false; if (bInitialized == false) { // 注册系统管理员 RoleFactory::Instance().RegisterRole("ROLE_ROOT_ADMIN", new RootAdminRole("ROLE_ROOT_ADMIN")); // 注册订单管理员 RoleFactory::Instance().RegisterRole("ROLE_ORDER_ADMIN", new OrderAdminRole("ROLE_ORDER_ADMIN")); // 注册普通用户 RoleFactory::Instance().RegisterRole("ROLE_NORMAL", new NormalRole("ROLE_NORMAL")); bInitialized = true; } }
接下来借助上面这个工厂,业务代码调用只需要一行代码,if / else
被消除的明明白白:
class JudgeRole { public: std::string Judge(const std::string &roleName) { return RoleFactory::Instance().GetRole(roleName)->Op(); } };
需要注意:在使用 Judge
时,要先调用初始化所有角色 InitializeRole
函数(可以放在 main
函数开头等):
int main() { InitializeRole(); // 优先初始化所有角色到工厂 JudgeRole judgeRole; std::cout << judgeRole.Judge("ROLE_ROOT_ADMIN") << std::endl; std::cout << judgeRole.Judge("ROLE_ORDER_ADMIN") << std::endl; std::cout << judgeRole.Judge("ROLE_NORMAL") << std::endl; }
通过工厂模式实现的方式,想扩展条件也很容易,只需要增加新代码,而不需要改动以前的业务代码,非常符合「开闭原则」
不知道小伙伴发现了没有,上面实现工厂类,虽然看来去井然有序,但是当使用不当时会招致程序奔溃,那么是什么情况会发生呢?
我们先来分析上面的工厂类对外的两个接口:
RegisterRole
注册角色指针对象到工厂GetRole
从工厂获取角色指针对象
难道是指针对象没有释放导致资源泄露?不,不是这个问题,我们也不必手动去释放指针,因为上面的工厂是「单例模式」,它的生命周期是从第一次初始化后到程序结束,那么程序结束后,操作系统自然就会回收工厂类里的所有指针对象资源。
但是当我们手动去释放从工厂获取的角色指针对象,那么就会有问题了:
RoleOperation* pRoleOperation = RoleFactory::Instance().GetRole(roleName); ... delete pRoleOperation; // 手动去释放指针对象
如果我们手动释放了指针对象,也就导致工厂里 map 中存放的指针对象指向了空,当下次再次使用时,就会招致程序奔溃!如下面的例子:
class JudgeRole { public: std::string Judge(const std::string &roleName) { RoleOperation *pRoleOperation = RoleFactory::Instance().GetRole(roleName); std::string ret = pRoleOperation->Op(); delete pRoleOperation; // 手动去释放指针对象 return ret; } }; int main() { InitializeRole(); // 优先初始化所有角色到工厂 JudgeRole judgeRole; std::cout << judgeRole.Judge("ROLE_ROOT_ADMIN") << std::endl; std::cout << judgeRole.Judge("ROLE_ROOT_ADMIN") << std::endl; // 错误!程序会奔溃退出! return 0; }
上面的代码在使用第二次 ROLE_ROOT_ADMIN
角色指针对象时,就会招致程序奔溃,因为 ROLE_ROOT_ADMIN
角色指针对象已经在第一次使用完后,被手动释放指针对象了,此时工厂 map 存放的就是空指针了。
可否优化呢?因为有的程序员是会手动释放从工厂获取的指针对象的。
上面的工厂类的缺陷就在于,new
初始化的指针对象只初始化了一次,如果手动 释放了指针对象,就会导致此指针对象指向空,再次使用就会导致系统奔溃。
为了改进这个问题,那么我们把 new
初始化方式放入工厂类获取指针对象的成员函数里,这也就每次调用该成员函数时,都是返回新 new
初始化过的指针对象,那么这时外部就需要由手动释放指针对象了。
下面的工厂类,改进了上面问题,同时采用模板技术,进一步对工厂类进行了封装,使得不管是角色类,还是其他类,只要存在多态特性的类,都可以使用此工厂类,可以说是「万能」的工厂类了:
接下来把新的「万能」工厂模板类,使用到本例的角色对象。
1. 把角色注册(聚合)到工厂的方式是构造 ProductRegistrar
对象 ,使用时需注意:
- 模板参数
ProductType_t
指定的是基类(如本例 RoleOperation ) - 模板参数
ProductImpl_t
指定的是派生类(如本例 RootAdminRole、OrderAdminRole 和 NormalRole)
我们使用新的注册(聚合)方式,对 InitializeRole
初始化角色函数改进下,参见下面:
void InitializeRole() // 初始化角色到工厂 { static bool bInitialized = false; if (bInitialized == false) { // 注册系统管理员 static ProductRegistrar<RoleOperation, RootAdminRole> rootRegistrar("ROLE_ROOT_ADMIN"); // 注册订单管理员 static ProductRegistrar<RoleOperation, OrderAdminRole> orderRegistrar("ROLE_ORDER_ADMIN"); // 注册普通用户 static ProductRegistrar<RoleOperation, NormalRole> normalRegistrar("ROLE_NORMAL"); bInitialized = true; } }
2. 从工厂获取角色指针对象的函数是 GetProduct
,需注意的是:
- 使用完角色指针对象后,需手动
delete
资源。
我们使用新的获取角色对象的方式,对 Judge
函数改进下,参见下面:
class JudgeRole { public: std::string Judge(const std::string &roleName) { ProductFactory<RoleOperation>& factory = ProductFactory<RoleOperation>::Instance(); // 从工厂获取对应的指针对象 RoleOperation *pRoleOperation = factory.GetProduct(roleName); // 调用角色的对应操作权限 std::string result = pRoleOperation->Op(); // 手动释放资源 delete pRoleOperation; return result; } };
唔,每次都手动释放资源这种事情,会很容易遗漏。如果我们遗漏了,就会招致了内存泄漏。为了避免此概率事情的发生,我们用上「智能指针],让它帮我们管理吧:
class JudgeRole { public: std::string Judge(const std::string &roleName) { ProductFactory<RoleOperation>& factory = ProductFactory<RoleOperation>::Instance(); std::shared_ptr<RoleOperation> pRoleOperation(factory.GetProduct(roleName)); return pRoleOperation->Op(); } };
采用了 std::shared_ptr
引用计数智能指针,我们不在需要时刻记住要手动释放资源的事情啦(我们通常都会忘记……),该智能指针会在当引用次数为 0 时,自动会释放掉指针资源。
来,我们接着来,除了工厂模式,策略模式也不妨试一试
策略模式 —— 它不香吗?
策略模式和工厂模式写起来其实区别也不大!策略模式也采用了面向对象的继承和多态机制。
在上面工厂模式代码的基础上,按照策略模式的指导思想,我们也来创建一个所谓的策略上下文类,这里命名为 RoleContext
:
class RoleContext { public: RoleContext(RoleOperation *operation) : m_pOperation(operation) { } ~RoleContext() { if (m_pOperation) { delete m_pOperation; } } std::string execute() { return m_pOperation->Op(); } private: // 禁止外部拷贝和赋值操作 RoleContext(const RoleContext &); const RoleContext &operator=(const RoleContext &); RoleOperation *m_pOperation; };
很明显上面传入的参数 operation
就是表示不同的「策略」。我们在业务代码里传入不同的角色,即可得到不同的操作结果:
class JudgeRole { public: std::string Judge(RoleOperation *pOperation) { RoleContext roleContext(pOperation); return roleContext.execute(); } }; int main() { JudgeRole judgeRole; std::cout << judgeRole.Judge(new RootAdminRole("ROLE_ROOT_ADMIN")) << std::endl; std::cout << judgeRole.Judge(new OrderAdminRole("ROLE_ORDER_ADMIN")) << std::endl; std::cout << judgeRole.Judge(new NormalRole("ROLE_NORMAL")) << std::endl; return 0; }
当然,上面策略类还可以进一步优化:
- 用模板技术进一步封装,使其不限制于角色类。
// 策略类模板 // 模板参数 ProductType_t,表示的是基类 template <class ProductType_t> class ProductContext { public: ProductContext(ProductType_t *operation) : m_pOperation(operation) { } ~ProductContext() { if (m_pOperation) { delete m_pOperation; } } std::string execute() { return m_pOperation->Op(); } private: // 禁止外部拷贝和赋值操作 ProductContext(const ProductContext &); const ProductContext &operator=(const ProductContext &); ProductType_t* m_pOperation; };
使用方式,没太大差别,只需要指定类模板参数是基类(如本例 RoleOperation
) 即可:
class JudgeRole { public: std::string Judge(RoleOperation *pOperation) { ProductContext<RoleOperation> roleContext(pOperation); return roleContext.execute(); } };
共勉
C++ 和 Java 语言都是面向对象编程的方式,所以都是可以通过面向对象和多态特性降低代码的耦合性,同时也可使得代码易扩展。所以对于写代码事情,不要着急下手,先思考是否有更简单、更好的方式去实现。
C++ 之父 Bjarne Stroustrup 曾经提及过程序员的三大美德是懒惰、急躁、傲慢,其中之一的懒惰这个品质,就是告知我们要花大力气去思考,避免消耗过多的精力个体力(如敲代码)。
若有错误或者不当之处,可在本公众号内反馈,一起学习交流!
推荐阅读:
- 掌握了多态的特性,写英雄联盟的代码更少啦!
- 学过 C++ 的你,不得不知的这 10 条细节!
关注公众号,后台回复「我要学习」,即可免费获取精心整理「服务器 Linux C/C++ 」成长路程(书籍资料 + 思维导图)
原文链接:https://www.cnblogs.com/xiaolincoding/p/12311371.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
上一篇:【做题笔记】P1969 积木大赛
下一篇:HihoCoder 1174
- C++ 转换函数搭配友元函数 2020-06-10
- C++ 自动转换和强制类型转换(用户自定义类类型) 2020-06-10
- C++ rand函数 2020-06-10
- C++ 友元函数 2020-06-10
- C++ 运算符重载 2020-06-10
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash