【more effective c++读书笔记】【第5章】技术(7)——让函数根据一个以上的对象类型来决定如何虚化(1)

本文主要是介绍【more effective c++读书笔记】【第5章】技术(7)——让函数根据一个以上的对象类型来决定如何虚化(1),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

一个虚函数调用动作称为一个消息分派,如果某个函数调用根据两个参数而虚化就称为双重分派,根据多个函数而虚化称为多重分派。C++不支持双重分派和多重分派,因此我们必须自己实现。有以下几种方法:

一、虚函数 + RTTI(运行时期类型辨识)

//GameObject.h
#ifndef GAMEOBJECT_H
#define GAMEOBJECT_Hclass GameObject{ //抽象基类
public:virtual void collide(GameObject& otherObject) = 0;
};class SpaceShip : public GameObject{ //宇宙飞船类
public:virtual void collide(GameObject& otherObject);
};class SpaceStation : public GameObject{ //太空站类
public:virtual void collide(GameObject& otherObject);
};class Asteroid : public GameObject{ //小行星类
public:virtual void collide(GameObject& otherObject);
};class CollisionWithUnkonwnObject{//异常类
public:CollisionWithUnkonwnObject(GameObject& whatWeHit);
};#endif
//GameObject.cpp
#include"GameObject.h"
#include<iostream>void SpaceShip::collide(GameObject& otherObject){const type_info& objectType = typeid(otherObject);if (objectType == typeid(SpaceShip)){SpaceShip& ss = static_cast<SpaceShip&>(otherObject);std::cout << "SpaceShip=>SpaceShip" << std::endl;}else if (objectType == typeid(SpaceStation)){SpaceStation& ss = static_cast<SpaceStation&>(otherObject);std::cout << "SpaceShip=>SpaceStation" << std::endl;}else if (objectType == typeid(Asteroid)){Asteroid& a = static_cast<Asteroid&>(otherObject);std::cout << "SpaceShip=>Asteroid" << std::endl;}else {throw CollisionWithUnkonwnObject(otherObject);}
}void SpaceStation::collide(GameObject& otherObject){const type_info& objectType = typeid(otherObject);if (objectType == typeid(SpaceShip)){SpaceShip& ss = static_cast<SpaceShip&>(otherObject);std::cout << "SpaceStation=>SpaceShip" << std::endl;}else if (objectType == typeid(SpaceStation)){SpaceStation& ss = static_cast<SpaceStation&>(otherObject);std::cout << "SpaceStation=>SpaceStation" << std::endl;}else if (objectType == typeid(Asteroid)){Asteroid& a = static_cast<Asteroid&>(otherObject);std::cout << "SpaceStation=>Asteroid" << std::endl;}else {throw CollisionWithUnkonwnObject(otherObject);}
}void Asteroid::collide(GameObject& otherObject){const type_info& objectType = typeid(otherObject);if (objectType == typeid(SpaceShip)){SpaceShip& ss = static_cast<SpaceShip&>(otherObject);std::cout << "Asteroid=>SpaceShip" << std::endl;}else if (objectType == typeid(SpaceStation)){SpaceStation& ss = static_cast<SpaceStation&>(otherObject);std::cout << "Asteroid=>SpaceStation" << std::endl;}else if (objectType == typeid(Asteroid)){Asteroid& a = static_cast<Asteroid&>(otherObject);std::cout << "Asteroid=>Asteroid" << std::endl;}else {throw CollisionWithUnkonwnObject(otherObject);}
}CollisionWithUnkonwnObject::CollisionWithUnkonwnObject(GameObject& whatWeHit){std::cout << "异常类" << std::endl;
}
//main.cpp
#include"GameObject.h"
#include<iostream>
using namespace std;int main(){SpaceShip sp;SpaceStation ss;Asteroid ad;sp.collide(sp);sp.collide(ss);sp.collide(ad);cout << "-----------" << endl;ss.collide(sp);ss.collide(ss);ss.collide(ad);cout << "-----------" << endl;ad.collide(sp);ad.collide(ss);ad.collide(ad);system("pause");return 0;
}

这种方法会破坏封装,因为每一个collide函数都必须知道其每一个兄弟类。如果有新型对象加入上述例子中,必须修改上述例子中的每一个可能遭遇新对象的RTTI-based if-then-else链。

二、只使用虚函数

//GameObject.h
#ifndef GAMEOBJECT_H
#define GAMEOBJECT_Hclass SpaceShip;
class SpaceStation;
class Asteroid;class GameObject{ //抽象基类
public:virtual void collide(GameObject& otherObject) = 0;virtual void collide(SpaceShip& otherObject) = 0;virtual void collide(SpaceStation& otherObject) = 0;virtual void collide(Asteroid& otherObject) = 0;
};class SpaceShip : public GameObject{ //宇宙飞船类
public:virtual void collide(GameObject& otherObject);virtual void collide(SpaceShip& otherObject);virtual void collide(SpaceStation& otherObject);virtual void collide(Asteroid& otherObject);
};class SpaceStation : public GameObject{ //太空站类
public:virtual void collide(GameObject& otherObject);virtual void collide(SpaceShip& otherObject);virtual void collide(SpaceStation& otherObject);virtual void collide(Asteroid& otherObject);
};class Asteroid : public GameObject{ //小行星类
public:virtual void collide(GameObject& otherObject);virtual void collide(SpaceShip& otherObject);virtual void collide(SpaceStation& otherObject);virtual void collide(Asteroid& otherObject);
};class CollisionWithUnkonwnObject{//异常类
public:CollisionWithUnkonwnObject(GameObject& whatWeHit);
};#endif
//GameObject.cpp
#include"GameObject.h"
#include<iostream>void SpaceShip::collide(GameObject& otherObject){otherObject.collide(*this);
}
void SpaceShip::collide(SpaceShip& otherObject){std::cout << "SpaceShip=>SpaceShip" << std::endl;
}
void SpaceShip::collide(SpaceStation& otherObject){std::cout << "SpaceShip=>SpaceStation" << std::endl;
}
void SpaceShip::collide(Asteroid& otherObject){std::cout << "SpaceShip=>Asteroid" << std::endl;
}void SpaceStation::collide(GameObject& otherObject){otherObject.collide(*this);
}
void SpaceStation::collide(SpaceShip& otherObject){std::cout << "SpaceStation=>SpaceShip" << std::endl;
}
void SpaceStation::collide(SpaceStation& otherObject){std::cout << "SpaceStation=>SpaceStation" << std::endl;
}
void SpaceStation::collide(Asteroid& otherObject){std::cout << "SpaceStation=>Asteroid" << std::endl;
}void Asteroid::collide(GameObject& otherObject){otherObject.collide(*this);
}
void Asteroid::collide(SpaceShip& otherObject){std::cout << "Asteroid=>SpaceShip" << std::endl;
}
void Asteroid::collide(SpaceStation& otherObject){std::cout << "Asteroid=>SpaceStation" << std::endl;
}
void Asteroid::collide(Asteroid& otherObject){std::cout << "Asteroid=>Asteroid" << std::endl;
}CollisionWithUnkonwnObject::CollisionWithUnkonwnObject(GameObject& whatWeHit){std::cout << "异常类" << std::endl;
}
//main.cpp
#include"GameObject.h"
#include<iostream>
using namespace std;int main(){SpaceShip sp;SpaceStation ss;Asteroid ad;sp.collide(sp);sp.collide(ss);sp.collide(ad);cout << "-----------" << endl;ss.collide(sp);ss.collide(ss);ss.collide(ad);cout << "-----------" << endl;ad.collide(sp);ad.collide(ss);ad.collide(ad);system("pause");return 0;
}

上述例子的基本思想是将双重分派以两个单一分派(也就是两个分离的虚函数调用)实现出来,其一用来决定第一对象的动态类型,其二用来决定第二对象的动态类型。缺点是与虚函数+ RTTI解法一样,每个类都必须知道其兄弟类。一旦有新的类加入,代码就必须修改。

三、自行仿真虚函数表格(使用成员函数的碰撞处理函数)

//GameObject.h
#ifndef GAMEOBJECT_H
#define GAMEOBJECT_H#include<string>
#include<map>class GameObject{ //抽象基类
public:virtual void collide(GameObject& otherObject) = 0;
};class SpaceShip : public GameObject{ //宇宙飞船类
public://使用成员函数的碰撞处理函数virtual void collide(GameObject& otherObject);virtual void hitSpaceShip(GameObject& spaceShip);virtual void hitSpaceStation(GameObject& spaceStation);virtual void hitAsteroid(GameObject& asteroid);
private:typedef void(SpaceShip::*HitFunctionPtr)(GameObject&);//成员函数指针//函数表的类型:每项关联了碰撞函数参数的动态类型名和碰撞函数本身  typedef std::map<std::string, HitFunctionPtr> HitMap;//在函数表中查找需要的碰撞函数  static HitFunctionPtr lookup(const GameObject& whatWeHit);//建立函数表static HitMap* initializeCollisionMap();
};class SpaceStation : public GameObject{ //太空站类
public://使用成员函数的碰撞处理函数virtual void collide(GameObject& otherObject);virtual void hitSpaceShip(GameObject& spaceShip);virtual void hitSpaceStation(GameObject& spaceStation);virtual void hitAsteroid(GameObject& asteroid);
private:typedef void(SpaceStation::*HitFunctionPtr)(GameObject&);//成员函数指针//函数表的类型:每项关联了碰撞函数参数的动态类型名和碰撞函数本身  typedef std::map<std::string, HitFunctionPtr> HitMap;//在函数表中查找需要的碰撞函数  static HitFunctionPtr lookup(const GameObject& whatWeHit);//建立函数表static HitMap* initializeCollisionMap();
};class Asteroid : public GameObject{ //小行星类
public://使用成员函数的碰撞处理函数virtual void collide(GameObject& otherObject);virtual void hitSpaceShip(GameObject& spaceShip);virtual void hitSpaceStation(GameObject& spaceStation);virtual void hitAsteroid(GameObject& asteroid);
private:typedef void(Asteroid::*HitFunctionPtr)(GameObject&);//成员函数指针//函数表的类型:每项关联了碰撞函数参数的动态类型名和碰撞函数本身  typedef std::map<std::string, HitFunctionPtr> HitMap;//在函数表中查找需要的碰撞函数  static HitFunctionPtr lookup(const GameObject& whatWeHit);//建立函数表static HitMap* initializeCollisionMap();
};class CollisionWithUnkonwnObject{//异常类
public:CollisionWithUnkonwnObject(GameObject& whatWeHit);
};#endif
//GameObject.cpp
#include"GameObject.h"
#include<memory>
#include<iostream>void SpaceShip::collide(GameObject& otherObject){HitFunctionPtr hfp = lookup(otherObject);if (hfp)(this->*hfp)(otherObject);elsethrow CollisionWithUnkonwnObject(otherObject);
}
void SpaceShip::hitSpaceShip(GameObject& spaceShip){SpaceShip& ss = dynamic_cast<SpaceShip&>(spaceShip);std::cout << "SpaceShip=>SpaceShip" << std::endl;
}
void SpaceShip::hitSpaceStation(GameObject& spaceStation){SpaceStation& ss = dynamic_cast<SpaceStation&>(spaceStation);std::cout << "SpaceShip=>SpaceStation" << std::endl;
}
void SpaceShip::hitAsteroid(GameObject& asteroid){Asteroid& as = dynamic_cast <Asteroid&>(asteroid);std::cout << "SpaceShip=>Asteroid" << std::endl;
}
//在函数表中查找需要的碰撞函数  
SpaceShip::HitFunctionPtr SpaceShip::lookup(const GameObject& whatWeHit){static std::auto_ptr<HitMap> collisionMap(initializeCollisionMap());HitMap::iterator mapEntry = (*collisionMap).find(typeid(whatWeHit).name());if (mapEntry == (*collisionMap).end()) return 0;return (*mapEntry).second;
}
//建立函数表
SpaceShip::HitMap* SpaceShip::initializeCollisionMap(){HitMap* phm = new HitMap;(*phm)["class SpaceShip"] = &hitSpaceShip;//对应typeid(whatWeHit).name()(*phm)["class SpaceStation"] = &hitSpaceStation;(*phm)["class Asteroid"] = &hitAsteroid;return phm;
}void SpaceStation::collide(GameObject& otherObject){HitFunctionPtr hfp = lookup(otherObject);if (hfp)(this->*hfp)(otherObject);elsethrow CollisionWithUnkonwnObject(otherObject);
}
void SpaceStation::hitSpaceShip(GameObject& spaceShip){SpaceShip& ss = dynamic_cast<SpaceShip&>(spaceShip);std::cout << "SpaceStation=>SpaceShip" << std::endl;
}
void SpaceStation::hitSpaceStation(GameObject& spaceStation){SpaceStation& ss = dynamic_cast<SpaceStation&>(spaceStation);std::cout << "SpaceStation=>SpaceStation" << std::endl;
}
void SpaceStation::hitAsteroid(GameObject& asteroid){Asteroid& as = dynamic_cast <Asteroid&>(asteroid);std::cout << "SpaceStation=>Asteroid" << std::endl;
}
//在函数表中查找需要的碰撞函数  
SpaceStation::HitFunctionPtr SpaceStation::lookup(const GameObject& whatWeHit){static std::auto_ptr<HitMap> collisionMap(initializeCollisionMap());HitMap::iterator mapEntry = (*collisionMap).find(typeid(whatWeHit).name());if (mapEntry == (*collisionMap).end()) return 0;return (*mapEntry).second;
}
//建立函数表
SpaceStation::HitMap* SpaceStation::initializeCollisionMap(){HitMap* phm = new HitMap;(*phm)["class SpaceShip"] = &hitSpaceShip;//对应typeid(whatWeHit).name()(*phm)["class SpaceStation"] = &hitSpaceStation;(*phm)["class Asteroid"] = &hitAsteroid;return phm;
}void Asteroid::collide(GameObject& otherObject){HitFunctionPtr hfp = lookup(otherObject);if (hfp)(this->*hfp)(otherObject);elsethrow CollisionWithUnkonwnObject(otherObject);
}
void Asteroid::hitSpaceShip(GameObject& spaceShip){SpaceShip& ss = dynamic_cast<SpaceShip&>(spaceShip);std::cout << "Asteroid=>SpaceShip" << std::endl;
}
void Asteroid::hitSpaceStation(GameObject& spaceStation){SpaceStation& ss = dynamic_cast<SpaceStation&>(spaceStation);std::cout << "Asteroid=>SpaceStation" << std::endl;
}
void Asteroid::hitAsteroid(GameObject& asteroid){Asteroid& as = dynamic_cast <Asteroid&>(asteroid);std::cout << "Asteroid=>Asteroid" << std::endl;
}
//在函数表中查找需要的碰撞函数  
Asteroid::HitFunctionPtr Asteroid::lookup(const GameObject& whatWeHit){static std::auto_ptr<HitMap> collisionMap(initializeCollisionMap());HitMap::iterator mapEntry = (*collisionMap).find(typeid(whatWeHit).name());if (mapEntry == (*collisionMap).end()) return 0;return (*mapEntry).second;
}
//建立函数表
Asteroid::HitMap* Asteroid::initializeCollisionMap(){HitMap* phm = new HitMap;(*phm)["class SpaceShip"] = &hitSpaceShip;//对应typeid(whatWeHit).name()(*phm)["class SpaceStation"] = &hitSpaceStation;(*phm)["class Asteroid"] = &hitAsteroid;return phm;
}CollisionWithUnkonwnObject::CollisionWithUnkonwnObject(GameObject& whatWeHit){std::cout << "异常类" << std::endl;
}
//main.cpp
#include"GameObject.h"
#include<iostream>
using namespace std;int main(){SpaceShip sp;SpaceStation ss;Asteroid ad;sp.collide(sp);sp.collide(ss);sp.collide(ad);cout << "-----------" << endl;ss.collide(sp);ss.collide(ss);ss.collide(ad);cout << "-----------" << endl;ad.collide(sp);ad.collide(ss);ad.collide(ad);system("pause");return 0;
}


这篇关于【more effective c++读书笔记】【第5章】技术(7)——让函数根据一个以上的对象类型来决定如何虚化(1)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/230508

相关文章

MySQL 中的 CAST 函数详解及常见用法

《MySQL中的CAST函数详解及常见用法》CAST函数是MySQL中用于数据类型转换的重要函数,它允许你将一个值从一种数据类型转换为另一种数据类型,本文给大家介绍MySQL中的CAST... 目录mysql 中的 CAST 函数详解一、基本语法二、支持的数据类型三、常见用法示例1. 字符串转数字2. 数字

Python内置函数之classmethod函数使用详解

《Python内置函数之classmethod函数使用详解》:本文主要介绍Python内置函数之classmethod函数使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地... 目录1. 类方法定义与基本语法2. 类方法 vs 实例方法 vs 静态方法3. 核心特性与用法(1编程客

Python函数作用域示例详解

《Python函数作用域示例详解》本文介绍了Python中的LEGB作用域规则,详细解析了变量查找的四个层级,通过具体代码示例,展示了各层级的变量访问规则和特性,对python函数作用域相关知识感兴趣... 目录一、LEGB 规则二、作用域实例2.1 局部作用域(Local)2.2 闭包作用域(Enclos

Python实现对阿里云OSS对象存储的操作详解

《Python实现对阿里云OSS对象存储的操作详解》这篇文章主要为大家详细介绍了Python实现对阿里云OSS对象存储的操作相关知识,包括连接,上传,下载,列举等功能,感兴趣的小伙伴可以了解下... 目录一、直接使用代码二、详细使用1. 环境准备2. 初始化配置3. bucket配置创建4. 文件上传到os

从入门到精通C++11 <chrono> 库特性

《从入门到精通C++11<chrono>库特性》chrono库是C++11中一个非常强大和实用的库,它为时间处理提供了丰富的功能和类型安全的接口,通过本文的介绍,我们了解了chrono库的基本概念... 目录一、引言1.1 为什么需要<chrono>库1.2<chrono>库的基本概念二、时间段(Durat

MySQL count()聚合函数详解

《MySQLcount()聚合函数详解》MySQL中的COUNT()函数,它是SQL中最常用的聚合函数之一,用于计算表中符合特定条件的行数,本文给大家介绍MySQLcount()聚合函数,感兴趣的朋... 目录核心功能语法形式重要特性与行为如何选择使用哪种形式?总结深入剖析一下 mysql 中的 COUNT

C++20管道运算符的实现示例

《C++20管道运算符的实现示例》本文简要介绍C++20管道运算符的使用与实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录标准库的管道运算符使用自己实现类似的管道运算符我们不打算介绍太多,因为它实际属于c++20最为重要的

Visual Studio 2022 编译C++20代码的图文步骤

《VisualStudio2022编译C++20代码的图文步骤》在VisualStudio中启用C++20import功能,需设置语言标准为ISOC++20,开启扫描源查找模块依赖及实验性标... 默认创建Visual Studio桌面控制台项目代码包含C++20的import方法。右键项目的属性:

MySQL 中 ROW_NUMBER() 函数最佳实践

《MySQL中ROW_NUMBER()函数最佳实践》MySQL中ROW_NUMBER()函数,作为窗口函数为每行分配唯一连续序号,区别于RANK()和DENSE_RANK(),特别适合分页、去重... 目录mysql 中 ROW_NUMBER() 函数详解一、基础语法二、核心特点三、典型应用场景1. 数据分

c++中的set容器介绍及操作大全

《c++中的set容器介绍及操作大全》:本文主要介绍c++中的set容器介绍及操作大全,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录​​一、核心特性​​️ ​​二、基本操作​​​​1. 初始化与赋值​​​​2. 增删查操作​​​​3. 遍历方