前言
反射的概念:
指程序在运行时,访问、检测和修改它本身状态或行为的一种能力。wikipedia
简单的来说,就是一种自描述和自控制的能力。如果联想到镜子,就可以很好的理解,你能通过镜子看到自己,包括自己的动作,自己的外表。唯一不同的地方是,计算机语言的反射能力还包含对看到的自己采取措施。
反射的作用
在计算机编程语言中,反射机制可以用来:
- 获取类型的信息,包括属性、方法
- 动态调用方法
- 动态构造对象
- 从程序集中获得类型
反射的缺点
- 性能:反射可以理解成是一种解释操作,这个过程总是要慢于直接调用的。当然,性能问题的程度是可以控制的,如果程序在很少涉及的地方使用,性能将不会是一个问题。
- 反射模糊了程序内部实际发生的事情,会比直接代码更加复杂。
缺点不能掩饰其优点,针对不同的场景使用合理的技术才是最高境界。
反射的使用场景
- 序列化(Serialization)和数据绑定(Data Binding)
- 远程方法调用(RMI)
- 对象/关系数据映射(O/R mapping)
关于c++的反射
我们知道,Java是原生支持反射机制的,通过Class类可以通过名称获得类对象,进一步操作。Python也支持反射机制,可以通过globals()获取对象map,也可以通过inspect模块,提供了自省的方法。但是C++呢?C++原生不支持反射机制,RTTI(运行时类型识别)也仅仅提供了类型的判断。
开闭原则是设计模式的原则之一,对修改是封闭,对扩展开放。一般来说,需要我们对类进行抽象,针对抽象的类进行编程。许多的设计模式中,为了能够满足这一点,我们常常使用一个配置文件,映射字符串与类型。然后通过反射机制获得字符串对应的对象,然后自动装配已达到易于扩展的目的。
本文主要介绍两个小的场景如何实现C++反射。实际上,C++并不是对反射支持的很好,要支持动态和静态反射,还需要慢慢去寻找,我给出一些资料
C++11 reflection library
RTTR 库
Boost.Mirror 库
Mirror C++ reflection library
本文讨论如何在C++中实现简单的反射。
场景
C++序列化,与反序列化。序列化就是将对象编程二进制的形式存储在磁盘上,或者通过网络传输给另一台机器。反序列化就是序列化的逆过程。但是这个逆过程,必须要根据字符串来判断将二进制流转化成什么类型的对象。
工厂模式,常常是根据一个字符串来获取想要的对象。但是为了满足开闭原则,我们不能简单的在工厂类中不断的修改生产函数来扩展不同的类型。这个时候,需要利用反射,使用抽象类。
实现
思路是:
- 使用map,映射字符串和生产函数
- 每次构造新类型时,将生产函数注册到map中
- 工厂函数通过map获得生产函数,建造不同的对象
方案一
- map存储在Object抽象父类中
- 使用ClassInfo辅助类型保存子类对象(包括了子类对象的构造函数)
- map映射结构—->子类名称:ClassInfo*
// Reflex.h
class Object{
public:
Object(){}
virtual ~Object(){}
static bool Register(ClassInfo *ci); // 注册函数
static Object *CreateObject(string name);
}
using ObjectConstructorFn = Object *(*)(void); // 构造函数指针
class ClassInfo {
public:
ClassInfo(const string classname, ObjectConstructorFn ctor)
:class_name_(classname), m_object_constructor_(ctor) {
Object::Register(this); // 注入到Object中
}
virtual ~ClassInfo(){};
Object *CreateObject() const { // 返回当前类型的构造函数
return m_object_constructor_ ? (*m_object_constructor_) : 0;
}
const string GetClassName() const {return class_name_;}
ObjectConstructorFn GetConstructor() {return m_object_constructor_;}
private:
string class_name_;
ObjectConstructorFn m_object_constructor_; // 维护对象信息
}
==============================================================
// Reflex.cpp
#include "Reflex.h"
static unordered_map<string, ClassInfo *> *class_map = nullptr; // 延迟到第一次注册
bool Object::Register(ClassInfo *ci) {
if (!class_map) {
class_map = new unordered_map<string, ClassInfo *>();
}
if (ci) {
// 如果没有注册过
string c_name = ci -> GetClassName();
if (class_map -> find(c_name) == class_map -> end()) {
class_map[c_name] = ci;
}
return true;
}
return false;
}
Object *Object::CreateObject(string name) {
// 如果注册过就直接调用classinfo的createobject
if (class_map -> find(name) != class_map.end())
return class_map[name] -> CreateObject();
return nullptr;
}
==============================================================
// test.cpp
class A : public Object {
public:
A(){}
~A(){}
ClassInfo *GetClassInfo const{ return &m_class_info_;}
// 自定义生产函数
static Object *CreateObject() {
return new A;
}
protected:
static ClassInfo m_class_info_;
}
// 最重要的一步,将当前类注册到Object中
ClassInfo A::m_class_info_("A", A::CreateObject);
int main() {
Object *obj = Object::CreateObject("A");
delete obj;
return 0;
}
上面的代码实现了简单的反射机制,但是还不够好。每次构建类都需要写许多重复性的代码。而C++的宏为我们提供了很好的工具来简化重复性的代码。如下:
// Reflex.h
// 向类中添加 class_info 属性以及 CreateObject、GetClassInfo方法
#define DECLEAR_CLASS(name) \
protected: \
static ClassInfo m_class_info_; \
public:
ClassInfo *GetClassInfo const; \
static Object *CreateObject(); \
// 实现CreateObject和GetClassInfo两个方法
#define IMPLEMENT_CLASS_COMMON(name, func) \
ClassInfo name::m_class_info_((#name), (ObjectConstructorFn) func); \
ClassInfo *name::GetClassInfo() const \
{ return &name::m_class_info_;}
// classInfo 属性的初始化
#define IMPLEMENT_CLASS(name) \
IMPLEMENT_CLASS_COMMON(name, name::CreateObject) \
Object* name::CreateObject() \
{ return new name;}
==============================================================
// test.cpp
class B : public Object {
DECLEAR_CLASS(B)
public:
B(){}
~B(){}
};
IMPLEMENT_CLASS(B)
方案二
- map存储在单例工厂类中
- 定义RegisterAction类型完成注册动作
- 同样使用宏将重复性的代码简化
//工厂类的定义
class ClassFactory{
private:
map<string, PTRCreateObject> m_classMap ;
ClassFactory(){}; //构造函数私有化
public:
void* getClassByName(string className);
void registClass(string name, PTRCreateObject method) ;
static ClassFactory& getInstance() ;
};
//工厂类的实现
//@brief:获取工厂类的单个实例对象
ClassFactory& ClassFactory::getInstance(){
static ClassFactory sLo_factory;
return sLo_factory ;
}
//@brief:通过类名称字符串获取类的实例
void* ClassFactory::getClassByName(string className){
map<string, PTRCreateObject>::const_iterator iter;
iter = m_classMap.find(className) ;
if ( iter == m_classMap.end() )
return NULL ;
else
return iter->second() ;
}
//@brief:将给定的类名称字符串和对应的创建类对象的函数保存到map中
void ClassFactory::registClass(string name, PTRCreateObject method){
m_classMap.insert(pair<string, PTRCreateObject>(name, method)) ;
}
//注册动作类
class RegisterAction{
public:
RegisterAction(string className,PTRCreateObject ptrCreateFn){
ClassFactory::getInstance().registClass(className,ptrCreateFn);
}
};
==============================================================
//test class B
class TestClassB{
public:
void m_print(){
cout<<"hello TestClassB"<<endl;
};
};
//@brief:创建类实例的回调函数
TestClassB* createObjTestClassB{
return new TestClassB;
}
//注册动作类的全局实例
RegisterAction g_creatorRegisterTestClassB("TestClassB",(PTRCreateObject)createObjTestClassB);
==============================================================
// 使用宏简化重复性代码
#define REGISTER(className) \
className* objectCreator##className(){ \
return new className; \
} \
RegisterAction g_creatorRegister##className( \
#className,(PTRCreateObject)objectCreator##className)
宏
既然提到了宏,这里简单的复习一下,宏是由 #define 定义而来。在预处理阶段进行宏展开。它的格式是:
#define <宏名> (<参数表>) <宏体>
#define N 2 + 2 // 仅仅是字符串替换
#define N (2 + 2) // 也是字符串 ,但是是(2 + 2)
#define area(x) (x) * (x) // 带参的宏定义参会当作字符串直接替换
三种特殊的符号:
# #define Conn(x, y) x##y // 表示连接,数字,字符串都可以
## #define ToString(x) #x // 就是加上双引号
#@ #define ToChar(x) #@x //就是加上单引号, 越界会报错
总结
反射在很多情况下都需要使用,应用场景比较广泛,希望读者能够仔细阅读代码。将反射机制使用在自己的工程里,实现一些设计良好的框架。另外,C++宏的使用可以极大的简化一些重复性的代码,可以仔细研究一下。