C++实现反射(根据类名动态创建对象)

最新推荐文章于 2024-08-24 20:37:42 发布
最新推荐文章于 2024-08-24 20:37:42 发布
阅读量2.8k 收藏 4
点赞数 1
分类专栏： C/C++语言 文章标签： C++反射

和网上大多数实现一样，这里也是采用工厂方法来实现对象的动态创建。大致原理为，创建一个单例工厂类，其中维护一个map(类名->对象创建函数)。创建对象时，传入类名，然后根据此类名查询出创建函数，最后创建对象。

    采用这种方式，有一个关键问题，便是在工厂中注册类名。我们的办法是针对于每一个类(Class)，定义一个注册类(ClassReg)，在注册类(ClassReg)的构造函数中注册此类(Class)，然后再定义一个注册类的全局对象，在该全局对象初始化时，便会执行注册代码完成注册。

    看到到这里懒人不乐意了，难道我们每写一个类，还要写一个相应的注册类？于是有人提出了使用宏来替换相应的代码，这样便大大减少了重复代码量。

    采用宏当然可以，但是只能满足部分懒人。还有一部分人更懒，他们连使用这个宏完成注册都不想干，是呀，每写完一个类，还要在类后面使用宏来注册，这样确实还是比较麻烦。而且这样代码不够美观，也不便于维护，同时采用宏来转换类名，遇到命名空间，嵌套类，会非常麻烦，我们必须在注册的时候，把名字写全，比如REG_CLASS(MyNameSpace::MyClass::MyStruct)。

    那么有没有更好的方法呢？当然有，我们可以用类模板来实现这种功能。设想这种方式，若我们要定义一个类MyClass，并且想让此类支持动态创建，那么我们只需这样定义即可class MyClass : public DynamicCreate<MyClass>{};。这样是不是清晰多了？下面请看代码:

    DynamicFactory.h文件

[cpp] view plain copy print ?
  1. #ifndef __DYNAMIC_FACTORY_H__  
  2. #define __DYNAMIC_FACTORY_H__  
  3.   
  4. #ifdef __GNUC__  
  5. #include <cxxabi.h>  
  6. #endif  
  7.   
  8. #include <assert.h>  
  9. #include <string.h>  
  10. #include <stdlib.h>  
  11. #include <map>  
  12. #include <string>  
  13. #include <typeinfo>  
  14.   
  15. // 动态对象基类  
  16. class DynamicObject  
  17. {  
  18. public:  
  19.     DynamicObject() {}  
  20.     virtual ~DynamicObject() {}  
  21. };  
  22.   
  23. // 动态对象创建工厂  
  24. class DynamicFactory  
  25. {  
  26. public:  
  27.   
  28.     typedef DynamicObject* (*CreateFunction)();  
  29.   
  30.     static DynamicFactory & Instance()  
  31.     {  
  32.         static DynamicFactory fac;  
  33.         return fac;  
  34.     }  
  35.   
  36.     // 解析类型名称（转换为 A::B::C 的形式）  
  37.     static std::string ReadTypeName(const char * name)  
  38.     {  
  39.                  // 这里省略，具体代码在最后给出  
  40.                  ...  
  41.     }  
  42.   
  43.     bool Regist(const char * name, CreateFunction func)  
  44.     {  
  45.         if (!func)  
  46.         {  
  47.             return false;  
  48.         }  
  49.         std::string type_name = ReadTypeName(name);  
  50.         return _create_function_map.insert(std::make_pair(type_name, func)).second;  
  51.     }  
  52.   
  53.     DynamicObject * Create(const std::string & type_name)  
  54.     {  
  55.         if (type_name.empty())  
  56.         {  
  57.             return NULL;  
  58.         }  
  59.   
  60.         std::map<std::string, CreateFunction>::iterator it = _create_function_map.find(type_name);  
  61.         if (it == _create_function_map.end())  
  62.         {  
  63.             return NULL;  
  64.         }  
  65.   
  66.         return it->second();  
  67.     }  
  68.   
  69.     template<typename T>  
  70.     T * Create(const std::string & type_name)  
  71.     {  
  72.         DynamicObject * obj = Create(type_name);  
  73.         if (!obj)  
  74.         {  
  75.             return NULL;  
  76.         }  
  77.         T * real_obj = dynamic_cast<T*>(obj);  
  78.         if (!real_obj)  
  79.         {  
  80.             delete obj;  
  81.             return NULL;  
  82.         }  
  83.         return real_obj;  
  84.     }  
  85.   
  86. public:  
  87.   
  88.     std::map<std::string, CreateFunction> _create_function_map;  
  89. };  
  90.   
  91. // 动态对象创建器  
  92. template<typename T>  
  93. class DynamicCreate : public DynamicObject  
  94. {  
  95. public:  
  96.     static DynamicObject * CreateObject()  
  97.     {  
  98.         return new T();  
  99.     }  
  100.   
  101.     struct Registor  
  102.     {  
  103.         Registor()  
  104.         {  
  105.             if (!DynamicFactory::Instance().Regist(typeid(T).name(), CreateObject))  
  106.             {  
  107.                 assert(false);  
  108.             }  
  109.         }  
  110.   
  111.         inline void do_nothing()const { }  
  112.     };  
  113.   
  114.     static Registor s_registor;  
  115.   
  116. public:  
  117.     DynamicCreate()  
  118.     {  
  119.         s_registor.do_nothing();  
  120.     }  
  121.   
  122.     virtual ~DynamicCreate()  
  123.     {  
  124.         s_registor.do_nothing();  
  125.     }  
  126. };  
  127.   
  128. template <typename T>  
  129. typename DynamicCreate<T>::Registor DynamicCreate<T>::s_registor;  
  130.   
  131. #endif  
#ifndef __DYNAMIC_FACTORY_H__
#define __DYNAMIC_FACTORY_H__

#ifdef __GNUC__
#include <cxxabi.h>
#endif

#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <map>
#include <string>
#include <typeinfo>

// 动态对象基类
class DynamicObject
{
public:
	DynamicObject() {}
	virtual ~DynamicObject() {}
};

// 动态对象创建工厂
class DynamicFactory
{
public:

	typedef DynamicObject* (*CreateFunction)();

	static DynamicFactory & Instance()
	{
		static DynamicFactory fac;
		return fac;
	}

	// 解析类型名称（转换为 A::B::C 的形式）
	static std::string ReadTypeName(const char * name)
	{
                 // 这里省略，具体代码在最后给出
                 ...
	}

	bool Regist(const char * name, CreateFunction func)
	{
		if (!func)
		{
			return false;
		}
		std::string type_name = ReadTypeName(name);
		return _create_function_map.insert(std::make_pair(type_name, func)).second;
	}

	DynamicObject * Create(const std::string & type_name)
	{
		if (type_name.empty())
		{
			return NULL;
		}

		std::map<std::string, CreateFunction>::iterator it = _create_function_map.find(type_name);
		if (it == _create_function_map.end())
		{
			return NULL;
		}

		return it->second();
	}

	template<typename T>
	T * Create(const std::string & type_name)
	{
		DynamicObject * obj = Create(type_name);
		if (!obj)
		{
			return NULL;
		}
		T * real_obj = dynamic_cast<T*>(obj);
		if (!real_obj)
		{
			delete obj;
			return NULL;
		}
		return real_obj;
	}

public:

	std::map<std::string, CreateFunction> _create_function_map;
};

// 动态对象创建器
template<typename T>
class DynamicCreate : public DynamicObject
{
public:
	static DynamicObject * CreateObject()
	{
		return new T();
	}

	struct Registor
	{
		Registor()
		{
			if (!DynamicFactory::Instance().Regist(typeid(T).name(), CreateObject))
			{
				assert(false);
			}
		}

		inline void do_nothing()const { }
	};

	static Registor s_registor;

public:
	DynamicCreate()
	{
		s_registor.do_nothing();
	}

	virtual ~DynamicCreate()
	{
		s_registor.do_nothing();
	}
};

template <typename T>
typename DynamicCreate<T>::Registor DynamicCreate<T>::s_registor;

#endif

    代码不多，就不做解释了。

    测试代码mian.cpp

[cpp] view plain copy print ?
  1. #include <stdio.h>  
  2. #include "DynamicFactory.h"  
  3.   
  4. class Test1 : public DynamicCreate<Test1>  
  5. {  
  6. public:  
  7.     // 注意：使用gcc，一定要显示申明构造函数，否则不会执行注册代码  
  8.     Test1() {}  
  9. };  
  10.   
  11. namespace OK {  
  12.     struct Test2 : public DynamicCreate<Test2>  
  13.     {  
  14.         Test2() {}  
  15.   
  16.         class Test3 : public DynamicCreate<Test3>  
  17.         {  
  18.         public:  
  19.             Test3() {}  
  20.         };  
  21.     };  
  22.   
  23.     struct Test4 : public DynamicCreate<Test4>  
  24.     {  
  25.         Test4() {}  
  26.     };  
  27. }  
  28.   
  29. using namespace OK;  
  30.   
  31. //测试代码  
  32. int main()  
  33. {  
  34.     Test1 * p1 = DynamicFactory::Instance().Create<Test1>("Test1");  
  35.     printf("Create Test1 %s\n", (p1 ? "success" : "failure"));  
  36.   
  37.     OK::Test2 * p2 = DynamicFactory::Instance().Create<OK::Test2>("OK::Test2");  
  38.     printf("Create OK::Test2 %s\n", (p2 ? "success" : "failure"));  
  39.   
  40.     OK::Test2::Test3 * p3 = DynamicFactory::Instance().Create<OK::Test2::Test3>("OK::Test2::Test3");  
  41.     printf("Create OK::Test2::Test3 %s\n", (p3 ? "success" : "failure"));  
  42.   
  43.     OK::Test4 * p4 = DynamicFactory::Instance().Create<OK::Test4>("OK::Test4");  
  44.     printf("Create OK::Test4 %s\n", (p4 ? "success" : "failure"));  
  45.   
  46.     return 0;  
  47. }  
#include <stdio.h>
#include "DynamicFactory.h"

class Test1 : public DynamicCreate<Test1>
{
public:
	// 注意：使用gcc，一定要显示申明构造函数，否则不会执行注册代码
	Test1() {}
};

namespace OK {
	struct Test2 : public DynamicCreate<Test2>
	{
		Test2() {}

		class Test3 : public DynamicCreate<Test3>
		{
		public:
			Test3() {}
		};
	};

	struct Test4 : public DynamicCreate<Test4>
	{
		Test4() {}
	};
}

using namespace OK;

//测试代码
int main()
{
	Test1 * p1 = DynamicFactory::Instance().Create<Test1>("Test1");
	printf("Create Test1 %s\n", (p1 ? "success" : "failure"));

	OK::Test2 * p2 = DynamicFactory::Instance().Create<OK::Test2>("OK::Test2");
	printf("Create OK::Test2 %s\n", (p2 ? "success" : "failure"));

	OK::Test2::Test3 * p3 = DynamicFactory::Instance().Create<OK::Test2::Test3>("OK::Test2::Test3");
	printf("Create OK::Test2::Test3 %s\n", (p3 ? "success" : "failure"));

	OK::Test4 * p4 = DynamicFactory::Instance().Create<OK::Test4>("OK::Test4");
	printf("Create OK::Test4 %s\n", (p4 ? "success" : "failure"));

	return 0;
}

  输出：

[plain] view plain copy print ?
  1. [programmer@localhost test]$ ./test  
  2. Create Test1 success  
  3. Create OK::Test2 success  
  4. Create OK::Test2::Test3 success  
  5. Create OK::Test4 success  
[programmer@localhost test]$ ./test
Create Test1 success
Create OK::Test2 success
Create OK::Test2::Test3 success
Create OK::Test4 success

  下面给出上面省略的 ReadTypeName函数代码

[cpp] view plain copy print ?
  1. // 解析类型名称（转换为 A::B::C 的形式）  
  2.     // GCC 的type_info::name()输出的名称很猥琐，这里只做简单的解析，只支持自定义的结构体（非模板），类（非模板）、枚举、联合  
  3.     static std::string ReadTypeName(const char * name)  
  4.     {  
  5. #ifndef __GNUC__  
  6.         const char * p = strstr(name, " ");  
  7.         if (p)  
  8.         {  
  9.             size_t prev_len = (size_t)(p - name);  
  10.             if (memcmp(name, "class", prev_len) == 0 ||  
  11.                 memcmp(name, "struct", prev_len) == 0 ||  
  12.                 memcmp(name, "enum", prev_len) == 0 ||  
  13.                 memcmp(name, "union", prev_len) == 0)  
  14.             {  
  15.                 p += 1;  
  16.                 return std::string(p);  
  17.             }  
  18.         }  
  19.   
  20.         return std::string(name);  
  21. #else  
  22.         char * real_name = abi::__cxa_demangle(name, nullptr, nullptr, nullptr);  
  23.              std::string real_name_string(real_name);  
  24.              free(real_name);  
  25.              return real_name_string;  
  26. #endif  
  27.     }  
// 解析类型名称（转换为 A::B::C 的形式）
	// GCC 的type_info::name()输出的名称很猥琐，这里只做简单的解析，只支持自定义的结构体（非模板），类（非模板）、枚举、联合
	static std::string ReadTypeName(const char * name)
	{
#ifndef __GNUC__
		const char * p = strstr(name, " ");
		if (p)
		{
			size_t prev_len = (size_t)(p - name);
			if (memcmp(name, "class", prev_len) == 0 ||
				memcmp(name, "struct", prev_len) == 0 ||
				memcmp(name, "enum", prev_len) == 0 ||
				memcmp(name, "union", prev_len) == 0)
			{
				p += 1;
				return std::string(p);
			}
		}

		return std::string(name);
#else
		char * real_name = abi::__cxa_demangle(name, nullptr, nullptr, nullptr);
             std::string real_name_string(real_name);
             free(real_name);
             return real_name_string;
#endif
	}
圆月弯刀丶
关注
专栏目录
C++反射动态创建所需类的实例
05-10
使用单例，工厂，函数指针实现的反射，减少了分支语句，次方法可以动态创建类实例，减少了工厂类里面的分支语句(工厂类完成后基本不需要修改，就可以随意创建想要的类的实例)。
深入探讨C++的高级反射机制（2）：写个能用的反射库
hebhljdx的博客
06-26 1492
在现代软件开发中，反射是一种强大的特性，它可以支持程序在运行时查询和调用对象的属性和方法。 但是在C++中，没有内置的反射机制。我们可以通过一些巧妙的技术模拟反射的部分功能。 我们这个简单反射库就称为refl吧。 refl库是一个用C++编写的轻量级反射框架，它允许在编译时和运行时对对象的属性和方法进行查询和操作。 这个库需要使用C++17编译器编译。其完整源码如下： #include <iostream> #include <tuple> #include <stdexcep
C++ 动态反射 第一版
最新发布
m0_56662207的博客
08-24 435
基于C++ 11 的 简单好用的C++ 反射库第一版
C++根据类名创造不同的类对象（反射）
netlogs的博客
04-16 2331
初衷 最近在写一个SDK，想实现一个管理类，通过传入不同的类名字符串，来实现动态创建不同类。 在Java等一些语音中，实现了一个机制：反射，个人理解可以通过字符串去创建对象，比如： std::string a = "testBase"; //反射即可以通过字符串变量‘a’，来达到创建类”testBase“的目的 这里折中了一下，不通过传入类名来达到创建类对象，而是通过回调函数的名字来达到创建类的目的。 C++实现 函数指针 typedef void* (*funcp)(); 定义一个基类，所有的动态类对
由类名创建对象(动态创建C++对象)
10-27 2003
  // 为编写方便，下面的代码都位于.cpp文件中#ifdef _MSC_VER#pragma warning(disable: 4786)#endif#include #include using namespace std;class Base{public: virtual void Print() // 测试用 {  cout  }protected: typedef Bas
c++ rtti 根据类名创建对象
08-08
实现c++根据类名创建c++ 对象，一个文件简单明了，，，，，
跟我学C++高级篇——名称反射创建对象的一种实现
fpcc的专栏
04-21 602
在后期的文章和实例中，大家会发现，会越来越多的把前面的知识融汇贯通，有可能再加上一些新知识点，就会实现一个比较好的技术点。所有的技术应用，一定是在基础技术上的不断的抽象升华。一种完全全新的，不以前边的技术为基础的技术，几乎很难遇到。或者如此说，即使遇到了，也可以通过老的技术快速的体会到新技术的优缺点。但这有一个前提，思想必须永远是开放包容，与时俱进！
qt通过类名动态创建对象
02-09
本篇文章将深入探讨如何在Qt中通过类名动态创建对象。 首先，我们需要了解Qt的元对象系统（Meta-Object System）。这个系统是Qt框架的一个核心特性，它为C++语言提供了运行时类型信息、信号与槽机制以及动态属性...
Qt 反射机制实现，通过类名创建对象
06-02
反射是指程序在运行时动态获取对象属性与...简单一点说，就是可以通过类名称来创建一个类对象，这在Java和Object-C中是原生支持的，所以实现起来非常简单，但是C++就不支持了，如果想要用到反射机制，那就得自己实现。
C++ 根据类名动态创建类对象
05-26
在 C++ 中，可以使用反射机制来根据类名动态创建类对象。 具体实现如下： 1. 首先需要使用 `#include <iostream>` 和 `#include <string>` 引入头文件。 2. 定义一个基类，例如 `Base` 类。 ```c++ class Base {...
C++动态生成对象
11-05
C++动态生成对象，支持属性注册，demo中有序列化的部分操作，使用tinyxml2来进行序列号操作
php动态创建类对象,通过类名动态生成对象
weixin_31081671的博客
03-17 765
问题前几天有人在PHP的QQ群里问生成对象的问题：use A\B;$b = new B(); // 正确$str = "B";$b = new $str(); // 错误，提示：类"B"未找到类似问题五六年前碰到过，因此印象深刻。热心提示要用 "完全限定类名" 形式，可惜连说两遍，提问题的人都没理解我说的(或者认为我的回复与其问题无关)： 不得已下，写下示范代码并 @ 提问题的人，终于让其明白：...
用c++11 实现类名反射对象
zhoumanman20的博客
07-24 1299
由于最近工作中用到工厂模式来创建不同的窗口对象在主窗口中显示， 以前遇到类似的情况我都是把所有需要创建的窗口类头文件都包含到主窗口MainWnd.cpp中， 这样每新增一个窗口， 就需要修改 MainWnd.cpp 。MainWnd.cpp 也就需要重新编译。后来百度了下c++反射， 有用Qt 元对象机制的（Qt继承自QObject 的类是可以支持反射的）； 有用模版实现的类工厂， 然后需要反射的类从该类继承； 也有模仿MFC 的（需要在类的声明和实现中加入相关宏）... 感觉都有点麻烦。 后来再百度..
C++反射，动态创建
whLBYX的博客
05-23 467
在 java 里有一个源生的反射机制，可以通过类的名字的字符串 动态的创建相应的类的实例化对象， 但是在 C++ 里却没有这样的机制，哎 作为 C++ 的粉，我心里顿时感觉到忧伤。难道就不行了吗？  当然是不可能！！！没有我们可以自己实现嘛！ 回想到 MFC 里的类型识别网，这里不就是动态创建的一个核心吗！恩恩稍微改改就可以了嘛！ 示意图： 大概思路：
C++之对象的序列化与反射
没闲的小孩多酱
03-25 1192
第一次接触对象的序列化与反射，理解尚浅，有什么不对的虚心接受指正。 在项目中，之前做过一个小功能，在系统开启后，会弹出一个进度条，是为了从数据库中将系统需要的数据读出来放到到内存，然后每读一部分，进度条会实时增加。之后的一次机会同事说，这个进度条可以再进行优化，像这样每次加载进度条都从数据库中读取，如果数据库繁忙，进度条会很慢，之后就提到的对象的反射。比如在网络通信中，因为不允许传递对象，可以将...
C++实现反射技术
IT女孩儿的日常的博客
06-10 7947
0 引言反射（reflection）的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用，并在Lisp和面向对象方面取得了成绩。同时，反射机制也被应用到了视窗系统、操作系统和文件系统中。反射是Java被认为是动态语言的一个非常重要的特性，它允许动态发现和绑...
C++编程语言中创建类的对象（类的初始化）的方法
热门推荐
liitdar的博客
08-07 4万+
使用new关键字创建的对象会赋值给类指针，该指针用途广泛，比如作为函数返回值、函数参数等；使用new关键字创建的对象在使用完成后，必须要使用delete销毁该对象，否则会造成内存泄露（new申请的对象，只有调用到delete时才会执行析构函数）；而直接使用类名创建的对象，则不需要手动销毁该对象，因为该类的析构函数会自动执行；使用new关键字创建的对象使用的是堆空间；而在局部、直接使用类名创建的对象则使用栈空间；
C++设计模式之动态创建
Sagittarius_Warrior的博客
11-25 1144
Abstract: 1，基本元素：工厂模式、函数指针和函数指针映射、链表、宏、静态全局变量控件、（虚函数）多态 2，链表地址追踪实验； 3，MFC动态创建原理演示； 4，自定义动态创建示例； 一、简述 动态创建（Dynamic Creation）是MFC六大核心机制之一。它的本质就是在运行时根据“类的某些信息”（如类名——字符串）创建对应的类对象，且客户代码（类对象的创建之处）无需包含待创建
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值