【effective c++读书笔记】【第6章】继承与面向对象设计(2)

最新推荐文章于 2020-08-24 21:57:15 发布
最新推荐文章于 2020-08-24 21:57:15 发布
阅读量335 收藏
点赞数
分类专栏： effective c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruan875417/article/details/47446461
版权

条款35：考虑virtual函数以外的其他选择

假设你在开发一款游戏，你打算为游戏内的人物设计一个继承体系。每个人物都有自己的健康状态。你能马上想到下面这个设计：

class GameCharacter{
public:
	virtual int healthValue()const;
};

有没有其他替代方案呢？答案是肯定的。

1、藉由Non-Virtual Interface手法实现Template Method模式

//GameCharacter.h
#ifndef GAMECHARACTER_H
#define GAMECHARACTER_H

class GameCharacter{
public:
	int healthValue() const;
private:
	virtual int getInitialValue() const;
	virtual int doHealthValue(int healthValue) const;
};
int GameCharacter::healthValue() const{
	int retVal = getInitialValue();
	retVal = doHealthValue(retVal);
	return retVal;
}
int GameCharacter::getInitialValue() const{
	return 100;
}
int GameCharacter::doHealthValue(int healthValue) const{
	return healthValue;
}

#endif

//EvilBadGuy.h
#ifndef EVILBADGUY_H
#define EVILBADGUY_H

#include"GameCharacter.h"

class EvilBadGuy:public GameCharacter{
private:
	virtual int getInitialValue() const;
	virtual int doHealthValue(int healthValue) const;
};
int EvilBadGuy::getInitialValue() const{
	return 400;
}
int EvilBadGuy::doHealthValue(int healthValue) const{
	return healthValue / 2;
}

#endif

//main.cpp
#include"EvilBadGuy.h"
#include<iostream>
using namespace std;

int main(){
	EvilBadGuy badGuy;
	cout << badGuy.healthValue() << endl;

	system("pause");
	return 0;
}

在基类GameCharacter中healthValue成员函数调用了doHealthValue函数，这种”令客户通过public non-virtual成员函数间接调用private virtual函数“，称为non-virtualinterface(NVI)手法。这个non-virtual(healthValue)函数称为virtual(doHealthValue)函数的外覆器(wrapper)。

NVI手法的一个优点是外覆器确保得以在一个virtual函数被调用之前设定好适当场景，并在调用结束之后清理场景。NVI手法允许继承类重新定义virtual函数，从而赋予它们”如何实现机能“的控制能力，但基类保留”函数何时被调用“的权利。

2、藉由Function Pointers实现Strategy模式

//GameCharacter.h
#ifndef GAMECHARACTER_H
#define GAMECHARACTER_H

class GameCharacter;
int defaultHealthCalc(const GameCharacter& gc);

class GameCharacter{
public:
	typedef int(*HealthCalcFunc)(const GameCharacter&);
	explicit GameCharacter(HealthCalcFunc hfc = defaultHealthCalc) :healthFunc(hfc){}
	int healthValue() const { return healthFunc(*this); }
	virtual int getInitialValue() const { return 50; }
private:
	HealthCalcFunc healthFunc;
};

int defaultHealthCalc(const GameCharacter& gc){
	return gc.getInitialValue();
}

#endif

//EvilBadGuy.h
#ifndef EVILBADGUY_H
#define EVILBADGUY_H

#include"GameCharacter.h"

class EvilBadGuy :public GameCharacter{
public:
	explicit EvilBadGuy(HealthCalcFunc hcf = defaultHealthCalc) :GameCharacter(hcf){}
	virtual int getInitialValue() const{ return 400; }
};

int loseHealthQuickly(const GameCharacter& gc){
	int retVal = gc.getInitialValue();
	retVal /= 4;
	return retVal;
}

int loseHealthSlowly(const GameCharacter& gc){
	int retVal = gc.getInitialValue();
	retVal /= 2;
	return retVal;
}

#endif

//main.cpp
#include"EvilBadGuy.h"
#include<iostream>
using namespace std;

int main(){
	EvilBadGuy badGuy1(loseHealthQuickly);
	cout << badGuy1.healthValue() << endl;

	EvilBadGuy badGuy2(loseHealthSlowly);
	cout << badGuy2.healthValue() << endl;

	system("pause");
	return 0;
}

这个做法是Strategy设计模式的简单应用，它提供了某些有趣弹性：

a、同一人物类型的不同实体可以有不同的健康计算函数，如main函数中的badGuy1和badGuy2。

b、某已知人物的健康指数计算函数可在运行期变更，如GameCharacter可提供一个成员函数setHealthCalculator，用来替换当前的健康指数计算函数。

3、藉由tr1::function完成Strategy模式

//GameCharacter.h
#ifndef GAMECHARACTER_H
#define GAMECHARACTER_H

#include<functional>

class GameCharacter;
short defaultHealthCalc(const GameCharacter& gc);//注意其返回类型不是int

class GameCharacter{
public:
	typedef std::function<int(const GameCharacter&)> HealthCalcFunc;
	explicit GameCharacter(HealthCalcFunc hfc = defaultHealthCalc) :healthFunc(hfc){}
	int healthValue() const { return healthFunc(*this); }
	virtual int getInitialValue() const { return 50; }
private:
	HealthCalcFunc healthFunc;
};

short defaultHealthCalc(const GameCharacter& gc){
	return gc.getInitialValue();
}

#endif

//EvilBadGuy.h
#ifndef EVILBADGUY_H
#define EVILBADGUY_H

#include"GameCharacter.h"

class EvilBadGuy :public GameCharacter{
public:
	explicit EvilBadGuy(HealthCalcFunc hcf = defaultHealthCalc) :GameCharacter(hcf){}
	virtual int getInitialValue() const{ return 400; }
};

struct LoseHealthQuickly{
	int operator()(const GameCharacter& gc) const{
		int retVal = gc.getInitialValue();
		retVal /= 4;
		return retVal;
	}
};

class GameLevel{
public:
	float loseHealthSlowly(const GameCharacter& gc) const{//注意返回类型不是int
		float retVal = static_cast<float>(gc.getInitialValue());
		retVal /= 2;
		return retVal;
	}
};

#endif

//main.cpp
#include"EvilBadGuy.h"
#include<iostream>
using namespace std;

int main(){
	EvilBadGuy badGuy1;//默认普通函数计算健康指数
	cout << badGuy1.healthValue() << endl;

	LoseHealthQuickly loseHealthQuickly;//函数对象计算健康指数
	EvilBadGuy badGuy2(loseHealthQuickly);
	cout << badGuy2.healthValue() << endl;

	GameLevel currentLevel;//成员函数计算健康指数
	EvilBadGuy badGuy3(bind(&GameLevel::loseHealthSlowly, currentLevel, placeholders::_1));
	cout << badGuy3.healthValue() << endl;

	system("pause");
	return 0;
}

这个做法与前面一个例子的区别：没有定义类型确定的函数指针，而是定义了一个类型为tr1:: function的对象。它的返回值为int或可转换为int的类型，输入参数为constGameCharacter引用或可以转化为constGameCharacter引用的类型。这样的对象可持有任何可调用物，即可以是一般函数指针、函数对象或成员函数指针，只要其签名式兼容于需求端。

对非静态成员函数，需要通过bind绑定。为了计算badGuy3的健康函数,需要使用GameLevel里面的loseHealthSlowly函数，这个函数实际上有两个参数：*this和GameCharacter&，而HealthCalcFunc只接受一个参数：GameCharacter&。需要将GameLevel类型中的loseHealthSlowly函数与调用它的对象绑定起来，此后每次调用loseHealthSlowly函数，都是调用绑定的那个对象的loseHealthSlowly函数。其中_1是占位符，表示的是这个函数的第一个参数。

4、古典的Strategy模式

//GameCharacter.h
#ifndef GAMECHARACTER_H
#define GAMECHARACTER_H

#include"HealthCalcFunc.h"

extern HealthCalcFunc defaultHealthCalc;
class GameCharacter{
public:
	explicit GameCharacter(HealthCalcFunc* phcf = &defaultHealthCalc) :pHealthFunc(phcf){}
	int healthValue() const { return pHealthFunc->calc(*this); }
	virtual int getInitialValue() const { return 50; }
private:
	HealthCalcFunc* pHealthFunc;
};

#endif

//EvilBadGuy.h
#ifndef EVILBADGUY_H
#define EVILBADGUY_H

#include"GameCharacter.h"

class EvilBadGuy :public GameCharacter{
public:
	explicit EvilBadGuy(HealthCalcFunc* phcf = &defaultHealthCalc) :GameCharacter(phcf){}
	virtual int getInitialValue() const{ return 400; }
};

#endif

//HealthCalcFunc.h
#ifndef HEALTHCALCFUNC_H
#define HEALTHCALCFUNC_H

class GameCharacter;
class HealthCalcFunc{
public:
	virtual int calc(const GameCharacter& gc) const;
};

class LoseHealthQuickly :public HealthCalcFunc{
public:
	virtual int calc(const GameCharacter& gc) const;
};

class LoseHealthSlowly :public HealthCalcFunc{
public:
	virtual int calc(const GameCharacter& gc) const;
};


#endif

//HealthCalcFunc.cpp
#include"GameCharacter.h"

int HealthCalcFunc::calc(const GameCharacter& gc) const{
	int retVal = gc.getInitialValue();
	return retVal;
}
int LoseHealthQuickly::calc(const GameCharacter& gc) const{
	int retVal = gc.getInitialValue();
	retVal /= 4;
	return retVal;
}
int LoseHealthSlowly::calc(const GameCharacter& gc) const{
	int retVal = gc.getInitialValue();
	retVal /= 2;
	return retVal;
}
HealthCalcFunc defaultHealthCalc;

//main.cpp
#include"EvilBadGuy.h"
#include<iostream>
using namespace std;

int main(){
	EvilBadGuy badGuy1;
	cout << badGuy1.healthValue() << endl;

	LoseHealthQuickly loseHealthQuickly;
	EvilBadGuy badGuy2(&loseHealthQuickly);
	cout << badGuy2.healthValue() << endl;

	LoseHealthSlowly loseHealthSlowly;
	EvilBadGuy badGuy3(&loseHealthSlowly);
	cout << badGuy3.healthValue() << endl;

	system("pause");
	return 0;
}

这个解法的吸引力在于熟悉标准Strategy模式的人很容易辨认它，可扩展性很强，可以加入不同的角色，只要从GameCharacter中派生即可，也可以加入新的健康算法，只要从HealthCalcFunc中派生即可。这个方法称为strategy模式，它的定义如下：Strategy模式定义了一系列的算法，将它们每一个进行封装，并使它们可以相互交换。Strategy模式使得算法不依赖于使用它的客户端。

对于虚函数，有以下几种替代方案：

a、 使用non-virtualinterface(NVI)手法。

b、将virtual函数替换为“函数指针成员变量“。这是Strategy设计模式的一种分解表现形式。

c、以tr1::function成员变量替换virtual函数。这也是Strategy设计模式的某种形式。

d、将继承体系内的virtual函数替换为另一个继承体系内的virtual函数。这是Strategy设计模式的传统实现方法。

请记住：

  • virtual函数的替代方案包括NVI手法及Strategy设计模式的多种形式。NVI手法自身是一个特殊形式的Template Method设计模式。
  • 将机能从成员函数移到class外部函数，带来的一个缺点是，非成员函数无法访问class的non-public成员。
  • tr1::function对象的行为就像一般函数指针。这样的对象可接纳“与给定之目标签名式（target signature）兼容”的所有可调用物（callable entities）。   

ruan875417
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
effective c++读书笔记
05-27
effective c++读书笔记和总结 effective c++读书笔记和总结
条款35、考虑虚函数以外的选择
lsfreeing的专栏
03-14 392
假设一个人物类，它有一个表现健康程度的的成员函数heath,返回一个数值表示人物健康程度。不同人物可能有不同的计算健康程度的方法，将其声明为虚函数是再明白不过的方法： class Character { public: virtual int heath () const; //返回健康指数，派生类可重载 … } health方法未声明为纯虚，暗示有计算健康指数的缺省方法。这个
Effective C++ 学习笔记 第六章：继承与面向对象设计
SiberiaBear的专栏
08-24 269
第一章见 Effective C++ 学习笔记 第一章：让自己习惯 C++ 第二章见 Effective C++ 学习笔记 第二章：构造、析构、赋值运算 第三章见 Effective C++ 学习笔记 第三章：资源管理 第四章见 Effective C++ 学习笔记 第四章：设计与声明 第五章见 Effective C++ 学习笔记 第五章：实现 文章目录条款 32：确定你的 public 继承塑造出 is-a 关系原书建议 条款 32：确定你的 public 继承塑造出 is-a 关系 Make su.
Effective C++读书笔记 第六部分 继承与面向对象设计
lxhjh的专栏
05-21 868
如果你了解C++各种特性的意义，你会发现，你对OOP的看法改变了。它不再是一项用来划分语言特性的仪典，而是可以让你通过它说出你对软件系统的想法。一旦你知道该通过它说些什么，移转至C++世界也就不再是可怕的高要求了。  条款32：确定你的public继承塑模出is-a关系     以C++进行面向对象编程，最重要的一个规则是：public inheritance（公有继承）意味is-a（是一种）
《Effective C++》读书笔记第六章——继承与面向对象设计（Inheritance and Object-Oriented Design）
哈哈哈哈嘿嘿嘿
11-01 184
条款32：确定你的public继承塑模出is-a关系 Make sure public inheritance models “is-a” “public继承”意味着is-a。适用于base classes身上的每一件事情一定也适用于derived classes身上，因为每一个derived class对象也都是一个base class对象。 eg： 1、“所有的鸟都会飞，企鹅是鸟，但是企鹅不...
effective C++ 读书笔记
11-20
effective C++ 很好 很不错 最好的C++进阶资料
effective C++读书笔记
06-13
effective C++读书笔记，effective C++读书笔记，effective C++读书笔记
c++ 面向对象的类设计
01-01
好像，more effective c++上说的，class的成员函数，应该是在完整的情况下保持最小化。但是，这里我们的出发点，是成员数据的完整最小化。 最小化的好处是可以保持概念最大的独立性，也意味着，可以用最小的代价来...
Effective Modern C++学习笔记
05-05
《Effective Modern C++:改善C++11和C++14的42个具体做法(影印版)(英文版)》中包括以下主题：剖析花括号初始化、noexcept规范、完美转发、智能指针make函数的优缺点；讲解std∷move，std∷forward，rvalue引用和全局...
【effective c++读书笔记】【第7章】模板和泛型编程(3)
ruan875417的专栏
08-17 575
条款46：需要类型转换时请为模板定义非成员函数 对条款24的例子进行模板化： #include using namespace std; template class Rational{ public: Rational(const T& n = 0, const T& d = 1) :numerator(n), denominator(d){}//构造函数刻意不为explicit，为了隐
【effective c++读书笔记】【第4章】设计与声明(2)
ruan875417的专栏
08-03 450
条款22：将成员变量声明为private 1、 如果成员变量不是public，客户唯一能够访问对象的办法就是通过成员函数。如果public接口内的每样东西都是函数，客户就不需要再打算访问class成员时迷惑地试着记住是否该使用小括号。 2、使用函数可以让你对成员变量的处理有更精确的控制。如果你令成员变量为public，每个人都可以读写它，但如果你以函数取得或设定其值，你就可以出现“不准访问”、
【effective c++读书笔记】【第8章】定制new和delete(2)
ruan875417的专栏
08-19 428
条款50：了解new和delete的合理替换时机 有人会想要替换掉编译器提供的operator new或operator delete，以下是几个理由： a、用来检测运用上的错误。编程过程中会出现各种错误。这些错误导致内存泄露(memory leaks)、不确定行为产生、overruns(写入点在分配区块尾端之后)、underruns(写入点在分配区块尾端之前)等的发生。定制的operator
【effective c++读书笔记】【第7章】模板和泛型编程(1)
ruan875417的专栏
08-15 426
条款41：了解隐式接口和编译期多态 1、模板的编译期多态 例子： #include using namespace std; class ClassA{ public: ClassA(size_t s) :size(s){} size_t getSize() const{ return size; } private: size_t size; }; class ClassB{ pu
【effective c++读书笔记】【第5章】实现(1)
ruan875417的专栏
08-04 409
条款26：尽可能延后变量定义式的出现时间 1、只要你定义了一个变量而其类型带有一个构造函数或析构函数，那么当程序的控制流到达这个变量定义式时，你便得承受构造成本；当这个变量离开其作用域时，你便得承受析构成本。即使这个变量最终并为被使用，仍需耗费这些成本，所以应该尽量避免这种情形。 例子： std::string encryptPassword(const std::string& passw
【effective c++读书笔记】【第4章】设计与声明(1)
ruan875417的专栏
08-02 406
条款18：让接口容易被正确使用，不容易被误用 1、许多客户端错误可以因为导入新类型而获得预防。在防范“不值得拥有的代码”上，类型系统是你的主要同盟国。 2、预防客户错误的另一个办法是，限制类型内什么事可做，什么事不能做。常见的限制是加上const。 3、除非有好理由，否则应该尽量令你的types的行为与内置types一致。 4、tr1::shared_ptr有一个特别好的性质是：它会自动使
【effective c++读书笔记】【第3章】资源管理
ruan875417的专栏
08-01 403
条款13:以对象管理资源 1、例子： #include using namespace std; class Test{ public: Test(){ cout << "Test构造" << endl; } ~Test(){ cout << "Test析构" << endl; } }; Test* createTest(){ return new Test(); } void f()
【effective c++读书笔记】【第7章】模板和泛型编程(2)
ruan875417的专栏
08-16 402
条款44：将与参数无关的代码抽离templates template是节省时间和避免重复代码的一个奇妙方法。class template的成员函数只有在被使用时才被暗中具现化。但是如果不小心，使用templates可能导致代码膨胀（code bloat）：其二进制代码带着重复（或几乎重复）的代码、数据、或两者。其结果可能源码看起来合身整齐，但目标码却不是那么回事。 假设你想为固定尺寸的正方矩阵
【effective c++读书笔记】【第6章】继承与面向对象设计(3)
ruan875417的专栏
08-13 377
条款36：绝不重新定义继承而来的non-virtual函数 1、例子 #include using namespace std; class Base{ public: void mf(){ cout << "Base::mf()" << endl; } }; class Derived :public Base{ public: void mf(){ cout << "Derived:
more effective c++:35个改善编程与设计的有效方法(中文版) .pdf
最新发布
07-27
《more effective c: 35个改善编程与设计的有效方法(中文版) 》是一本非常实用的书籍，它提供了许多改善编程与设计的有效方法。以下是对该书的回答： 这本书共包含了35个方法，旨在帮助读者提高编程和设计的效率。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值