C++动态反射第二版

已于 2024-08-28 03:52:12 修改
阅读量140 收藏
点赞数 4
分类专栏： C++ template 文章标签： c++
于 2024-08-28 03:46:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56662207/article/details/141615914
版权

 后续：后续还会继续添加新的功能，类反射还没写，后续内容不限于类反射！！！

注意啊：

        你在通过子类实例对象访问父类的函数或者属性的时候，会自动进行this指针调整的，现在自己在通过直接操作内存修改属性，不会帮你自动进行this指针调整，使用需要自己来实现。只有这样才可以进行正确的属性修改。 

第一版：

        1：这个C++ 反射库功能比较少，但是使用起来比较简单。

        2：功能：支持属性类型信息查看，属性值获取，属性值设置，成员函数反射，成员函        数类型信息查看。

第二版：

        1：在第一版的基础上新增可以通过子类反射父类的成员变量，可以根据字段所属类进行this指针调整来修改和获取字段值。

        2：对适用于反射的Object对象进行安全处理，加强安全性，即使你转换类型不一致也不会崩溃。

 1：Reflect.h

#ifndef REFLECT_H
#define REFLECT_H

#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>

#ifdef _WIN32
	#define REFLECT_EXPORT				__declspec(dllexport)
	//windows x86 or x68
	#ifdef _WIN64 //x64 windows
		typedef signed	long long		pointer_int;
	#else //x86 windows
		typedef signed	int				pointer_int;
	#endif //end of _WIN64
#else //unix
	#define REFLECT_EXPORT				
	#ifdef __x86_64__ //x64 unix
		typedef signed	long long		pointer_int;
	#elif __i386__ //x86 unix
		typedef signed	int				pointer_int;
	#endif //end of __x86_64__

#endif //end of _WIN32
#define LocalOffset(func) *(pointer_int*)((pointer_int)&func)
namespace Trds {
namespace Reflect {

class TrdsObject;

	// 是否启用C++17
#if __cplusplus >= 201703L
#define CPP_HAS_17 1
#endif
// Error id
constexpr int error_id_0_Unclear = 0;
constexpr int error_id_1_too_few_parameters = 1;
constexpr int error_id_2_too_many_parameters = 2;
constexpr int error_id_3_types_do_not_match = 3;

static const char* error_buffer[]
{
	"Unknown exception. Please carefully check whether the number of parameter bindings or the types of parameter bindings are correct. Note that the type of the incoming parameters needs to strictly correspond.",
	"Too few parameters are passed in",
	"Too many parameters are passed in",
	"The parameter types do not match"
};

class ICallBackException : public std::exception {
public:
	ICallBackException(int error_id = 0)
	{
		m_error_id = error_id;
	}

	virtual const char* what()const override
	{
		return error_buffer[m_error_id];
	}

private:
	int m_error_id{ 0 };
};

class CallBackExceptionUnClear : public ICallBackException
{
public:
	CallBackExceptionUnClear()
		:ICallBackException(error_id_0_Unclear)
	{

	}
};

class CallBackExceptionFewParameters : public ICallBackException
{
public:
	CallBackExceptionFewParameters()
		:ICallBackException(error_id_1_too_few_parameters)
	{

	}
};

class CallBackExceptionManyParameters : public ICallBackException
{
public:
	CallBackExceptionManyParameters()
		:ICallBackException(error_id_2_too_many_parameters)
	{

	}
};

class CallBackExceptionNotMatch : public ICallBackException
{
public:
	CallBackExceptionNotMatch()
		:ICallBackException(error_id_3_types_do_not_match)
	{

	}
};

template<typename T> struct Array { using type = T*; };
template<typename T> struct Array<T*> { using type = T(*)[1]; };
template<> struct Array<void*> { using type = void**; };
template<typename T> struct Array<T[]> { using type = T(*)[1]; };

template<typename T> struct function_traits;
template<typename R, typename ...Args>
struct function_traits<R(Args...)>
{
	enum
	{
		arity = sizeof...(Args)
	};
	static const  char* typeinfos[arity + 1];
	typedef R Ret;
	typedef R function(Args...);
	typedef R(*function_pointer)(Args...);
	using args_tuple_pointer = std::tuple<typename Array<std::remove_cv_t<std::remove_reference_t<Args>>>::type...>;
};
template<typename R, typename ...Args>
const char* function_traits<R(Args...)>::typeinfos[arity + 1] = { typeid(Args).name()... };

template<typename R, typename Type, typename ...Args> struct function_traits<R(Type::*)(Args...)> : public function_traits<R(Args...)> { using object = Type; using object_pointer = Type*; };
template<typename R, typename Type, typename ...Args> struct function_traits<R(Type::*)(Args...)const> : public function_traits<R(Args...)> { using object = Type; using object_pointer = Type*; };

class Object final
{
public:
	Object()
	{
		data_.reset();
	}

	template <typename T>
	Object(T* data, bool isHeap = true)
	{
		data_.reset(new ObjectTemplat<T>(data, isHeap));
	}

	template <typename T>
	Object(const T& data)
	{
		data_.reset(new ObjectTemplat<T>(data));
	}

	Object(const Object& rvalue) noexcept
	{
		data_ = rvalue.data_;
	}

	Object(Object&& rvalue) noexcept
	{
		data_.swap(const_cast<Object&>(rvalue).data_);
	}

	Object& operator=(const Object& rvalue) noexcept
	{
		data_ = rvalue.data_;
		return*this;
	}

	Object& operator=(Object&& rvalue) noexcept
	{
		data_.swap(const_cast<Object&>(rvalue).data_);
		return*this;
	}

	void Release()
	{
		data_->Release();
	}

	operator bool()const
	{
		return data_.get();
	}

	char* GetCharPtr()const
	{
		return data_->GetCharPtr();
	}

	int GetSize()const
	{
		return data_->GetSize();
	}

	bool IsPtr()const
	{
		return data_->IsPtr();
	}

	void SetSize(int size)
	{
		data_->SetSize(size);
	}

	template <typename T, typename U = char>
	T Value()
	{
		if (GetSize() != sizeof(T))
		{
			return T();
		}
		ObjectTemplat<U>* vptr = dynamic_cast<ObjectTemplat<U>*>(data_.get());
		return *(T*)vptr->Get();
	}

	class IBaseVlaue
	{
	public:
		virtual void SetSize(int size) = 0;
		virtual void Release() = 0;
		virtual bool IsPtr()const = 0;
		virtual ~IBaseVlaue() = default;
		virtual char* GetCharPtr()const = 0;
		virtual int GetSize()const = 0;
	};

	template <typename T> class ObjectTemplat : public IBaseVlaue
	{
	public:
		ObjectTemplat(const T& data)
			: isHeap(true)
		{
#ifdef CPP_HAS_17
			if constexpr (std::is_void_v<T>)
			{
				data_ = data;
			}
			else
			{
#endif
				data_ = new T(data);
#ifdef CPP_HAS_17
			}
#endif
			size_ = sizeof(T);
			isPointer = false;
		}

		ObjectTemplat(const T* data)
			: isHeap(true)
		{
			data_ = const_cast<T*>(data);
			size_ = sizeof(T*);
			isPointer = true;
		}

		ObjectTemplat(T* data, bool isHeap)
			: isHeap(isHeap), data_(data)
		{
			size_ = sizeof(T*);
			isPointer = true;
		}

		~ObjectTemplat()
		{
			if (isHeap && data_)
			{
				delete data_;
			}
			data_ = nullptr;
		}

		virtual char* GetCharPtr()const
		{
			return reinterpret_cast<char*>(data_);
		}

		virtual int GetSize()const override
		{
			return size_;
		}

		virtual bool IsPtr()const
		{
			return isPointer;
		}

		virtual void Release() override
		{
			isHeap = false;
		}

		virtual void SetSize(int size) override
		{
			size_ = size;
		}

		T* Get()
		{
			return data_;
		}
	private:
		bool isPointer = false;
		bool isHeap;
		T* data_;
		int size_ = 0;
	};

	template <> class ObjectTemplat<void> : public IBaseVlaue
	{
	public:
		ObjectTemplat(void* data)
			: isHeap(true)
		{
			data_ = data;
			size_ = sizeof(void*);
		}

		ObjectTemplat(void* data, bool isHeap)
			: isHeap(isHeap), data_(data)
		{
			size_ = sizeof(void*);
		}

		~ObjectTemplat()
		{
			if (isHeap && data_)
			{
				::free(data_);
			}
			data_ = nullptr;
		}

		virtual char* GetCharPtr()const
		{
			return reinterpret_cast<char*>(data_);
		}

		virtual int GetSize()const override
		{
			return size_;
		}

		virtual bool IsPtr()const
		{
			return true;
		}

		virtual void Release() override
		{
			isHeap = false;
		}

		virtual void SetSize(int size) override
		{
			size_ = size;
		}

		void* Get()
		{
			return data_;
		}
	private:
		bool isHeap;
		void* data_;
		int size_ = 0;
	};

private:
	std::shared_ptr<IBaseVlaue> data_;
};

class MetaFunction
{
public:
	MetaFunction()
	{
		pBinder.reset();
		mObj = nullptr;
	}
	
	template <typename R, typename Cla, typename... Args>
	MetaFunction(const std::string& function_, R(Cla::* Call)(Args...))
	{
		pBinder.reset(new CPFunction<R(Cla::*)(Args...)>(function_, Call));
		mObj = nullptr;
	}

	template <typename R, typename Cla, typename... Args>
	MetaFunction(const std::string& function_, R(Cla::* Call)(Args...)const)
	{
		pBinder.reset(new CPFunction<R(Cla::*)(Args...)const>(function_, Call));
		mObj = nullptr;
	}


	MetaFunction(const MetaFunction& ot) noexcept
	{
		pBinder = ot.pBinder;
		mObj = ot.mObj;
	}

	MetaFunction(MetaFunction&& ot) noexcept
	{
		pBinder.swap(ot.pBinder);
		mObj = ot.mObj;
	}

	MetaFunction& operator=(const MetaFunction& ot) noexcept
	{
		pBinder = ot.pBinder;
		mObj = ot.mObj;
		return*this;
	}

	MetaFunction& operator=(MetaFunction&& ot) noexcept
	{
		pBinder.swap(ot.pBinder);
		mObj = ot.mObj;
		return*this;
	}
	
	void setTrdsObject(TrdsObject* obj_)
	{
		mObj = obj_;
	}

	std::string GetName()const
	{
		return pBinder->GetName();
	}

	int GetLocalOffset()const
	{
		return pBinder->GetLocalOffset();
	}

	template <typename... Args>
	Object operator()(Args&&... args) const& noexcept
	{
		auto& args_tuple = std::make_tuple(std::addressof(args)...);
		const char* in[] = { 0, typeid(Args).name()... };
		return pBinder->Call(mObj, &args_tuple, sizeof...(Args), in);
	}
	operator bool()
	{
		return pBinder.get() != nullptr;
	}

protected:
	class IBinderTemplate
	{
	private:
		const std::string mName;
		const pointer_int local_offset;

	public:
		IBinderTemplate(const std::string& mName, pointer_int local_offset) : mName(mName), local_offset(local_offset){}
		virtual Object Call(TrdsObject* mObj, void* args, int count, const char** in) = 0;
		int GetLocalOffset()const { return local_offset; }
		virtual std::string GetName()const
		{
			return mName;
		}

		void Check(const char** need, const char** real, int nneed, int nreal)
		{
			if (nneed < nreal)
			{
				throw CallBackExceptionManyParameters();
			}
			
			if (nneed > nreal)
			{
				throw CallBackExceptionFewParameters();
			}

			for (int index_ = 0; index_ < nreal; ++index_)
			{
				if (strcmp(real[index_ + 1], need[index_]) != 0)
				{
					throw CallBackExceptionNotMatch();
				}
			}
		}

		virtual ~IBinderTemplate()
		{

		}

#ifdef CPP_HAS_17

		template<typename RS, typename Function, typename Caller, typename Cla, size_t ...II>
		Object CallBack(void* args, Cla* obj, Caller& caller, const std::index_sequence<II...>&)
		{
			using tupleArgs = typename function_traits<Function>::args_tuple_pointer;
			tupleArgs& tuple = *reinterpret_cast<tupleArgs*>(args);

			if constexpr (std::is_void_v<RS>)
			{
				(obj->*caller)(*std::get<II>(tuple)...);
				return Object();
			}
			else
			{
				return (obj->*caller)(*std::get<II>(tuple)...);
			}
		}
	};

#else
	template<typename RS, typename Function, typename Caller, typename Cla, size_t ...II>
	Object CallBack(RS*&, void* args, Cla* obj, Caller& caller, const std::index_sequence<II...>&)
	{
		using tupleArgs = typename function_traits<Function>::args_tuple_pointer;
		tupleArgs& tuple = *reinterpret_cast<tupleArgs*>(args);

		return (obj->*caller)(*std::get<II>(tuple)...);
	}

	template<typename RS, typename Function, typename Caller, typename Cla, size_t ...II>
	Object CallBack(void*&, void* args, Cla* obj, Caller& caller, const std::index_sequence<II...>&)
	{
		using tupleArgs = typename function_traits<Function>::args_tuple_pointer;
		tupleArgs& tuple = *reinterpret_cast<tupleArgs*>(args);

		(obj->*caller)(*std::get<II>(tuple)...);
		return Object();
	}
};

#endif
	template <typename CallAble, typename... BindArgs> class CPFunction;

	template <typename R, typename Cla, typename... Args>
	class CPFunction<R(Cla::*)(Args...)> : public IBinderTemplate
	{
		using Function = R(Cla::*)(Args...);
	public:
		CPFunction(const std::string& function_, Function func)
			: mCall(func), IBinderTemplate(function_, LocalOffset(func))
		{

		}

		virtual Object Call(TrdsObject* mObj, void* args, int count, const char** in) override
		{
			Check(function_traits<Function>::typeinfos, in, function_traits<Function>::arity, count);
			using Ret = typename function_traits<Function>::Ret;
#ifdef CPP_HAS_17
			return CallBack<Ret, Function, Function, Cla>(args, dynamic_cast<Cla*>(mObj), mCall, std::make_index_sequence<function_traits<Function>::arity>());
#else
			Ret* temp = 0;
			return CallBack<Ret, Function, Function, Cla>(temp, args, dynamic_cast<Cla*>(mObj), mCall, std::make_index_sequence<function_traits<Function>::arity>());
#endif
		}

	private:
		Function mCall;
	};

	template <typename R, typename Cla, typename... Args>
	class CPFunction<R(Cla::*)(Args...)const> : public IBinderTemplate
	{
		using Function = R(Cla::*)(Args...)const;
	public:
		CPFunction(const std::string& function_, Function func)
			: mCall(func), IBinderTemplate(function_, LocalOffset(func))
		{

		}

		virtual Object Call(TrdsObject* mObj, void* args, int count, const char** in) override
		{
			Check(function_traits<Function>::typeinfos, in, function_traits<Function>::arity, count);
			using Ret = typename function_traits<Function>::Ret;
#ifdef CPP_HAS_17
			return CallBack<Ret, Function, Function, Cla>(args, dynamic_cast<Cla*>(mObj), mCall, std::make_index_sequence<function_traits<Function>::arity>());
#else
			Ret* temp = 0;
			return CallBack<Ret, Function, Function, Cla>(temp, args, dynamic_cast<Cla*>(mObj), mCall, std::make_index_sequence < function_traits<Function>::arity>());
#endif
		}

	private:
		Function mCall;
	};

private:
	std::shared_ptr<IBinderTemplate>	pBinder;
	TrdsObject*							mObj;
};


class Field;
class MetaObject;
class MetaObjectImpl;
class MetaImpl;
class FieldImpl;
class SGenerateClassOffset;
class RegisterHelper;

using Supers = std::map<std::string, std::vector<SGenerateClassOffset>>;
using News = std::map<std::string, MetaFunction>;
using Invokes = std::map<std::string, std::vector<MetaFunction>>;
using Fields = std::map<std::string, std::vector<std::shared_ptr<Field>>>;
using MetaObjectPtr = std::shared_ptr<MetaObject>;
using TrdsObjectPtr = std::shared_ptr<TrdsObject>;
using FieldPtr = std::shared_ptr<Field>;

#define MEMBER_OFFSET(class, field)	(pointer_int)(&((class*)0)->field)
#define MEMBER_SIZEOF(class, field)	sizeof((((class*)0)->field))

#define CLASS_NAME(class)	virtual std::string GetClassName()const { return #class; }
#define OBJECT_NAME			public: virtual std::string GetObjName()const { return mName; } virtual std::string SetObjName(const std::string& name) { return mName = name; } private: std::string mName = "default";
#define TRDS_RELECT(class)  public: virtual MetaObjectPtr Meta(){ if(!metaobj_) { metaobj_.swap(Meta::GetInstance()->GetMetaObject(this, #class));}  return metaobj_; } CLASS_NAME(class)

#define REGISTER_FIELD(class, name)		RegisterHelper class##_##name##_Register(#class, #name, MEMBER_OFFSET(class, name), MEMBER_SIZEOF(class, name), SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" });
#define REGISTER_INVOKE(class, name)	RegisterHelper class##_##name##_function_Register(#class, MetaFunction(#name, &class::name));

#define REGISTER_MULTI_SUPER_1(class,	_1) RegisterHelper  _1_##class##_##_Superdata(#class, std::vector<SGenerateClassOffset>{     \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }});

#define REGISTER_MULTI_SUPER_2(class,	_1, _2) RegisterHelper  _2_##class##_##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 }});

#define REGISTER_MULTI_SUPER_3(class,	_1, _2, _3) RegisterHelper  _3_##class##_##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 }\
											});

#define REGISTER_MULTI_SUPER_4(class,	_1, _2, _3, _4) RegisterHelper  _4_##class##_##_4##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 }\
																									});
#define REGISTER_MULTI_SUPER_5(class,	_1, _2, _3, _4, _5) RegisterHelper  _5_##class##_##_5##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _5>().offset(), #_5 }	\
																						});
#define REGISTER_MULTI_SUPER_6(class,	_1, _2, _3, _4, _5, _6) RegisterHelper  _6_##class##_##_6##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _5>().offset(), #_5 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _6>().offset(), #_6 }\
																							});
#define REGISTER_MULTI_SUPER_7(class,	_1, _2, _3, _4, _5, _6, _7) RegisterHelper  _7_##class##_##_7##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _5>().offset(), #_5 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _6>().offset(), #_6 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _7>().offset(), #_7 }\
																							});
#define REGISTER_MULTI_SUPER_8(class,	_1, _2, _3, _4, _5, _6, _7, _8) RegisterHelper  _8_##class##_##_8##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 }, \
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _5>().offset(), #_5 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _6>().offset(), #_6 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _7>().offset(), #_7 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _8>().offset(), #_8 }\
																							});
#define REGISTER_MULTI_SUPER_9(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9) RegisterHelper  _9_##class##_##_9##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _5>().offset(), #_5 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _6>().offset(), #_6 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _7>().offset(), #_7 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _8>().offset(), #_8 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _9>().offset(), #_9 }\
																							});
#define REGISTER_MULTI_SUPER_10(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) RegisterHelper  _10_##class##_##_10##_Superdata(#class, std::vector<SGenerateClassOffset>{ \
											SGenerateClassOffset{ GenerateClassOffset<class, TrdsObject>().offset(), "TrdsObject" },\
											SGenerateClassOffset{ GenerateClassOffset<class, _1>().offset(), #_1 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _2>().offset(), #_2 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _3>().offset(), #_3 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _4>().offset(), #_4 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _5>().offset(), #_5 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _6>().offset(), #_6 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _7>().offset(), #_7 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _8>().offset(), #_8 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _9>().offset(), #_9 },\
											SGenerateClassOffset{ GenerateClassOffset<class, _10>().offset(), #_10 }\
																							});


#define REGISTER_MULTI_FIELD_1(class,	_1) REGISTER_FIELD(class, _1)
#define REGISTER_MULTI_FIELD_2(class,	_1, _2) REGISTER_MULTI_FIELD_1(class, _1) REGISTER_FIELD(class, _2)
#define REGISTER_MULTI_FIELD_3(class,	_1, _2, _3) REGISTER_MULTI_FIELD_2(class, _1, _2) REGISTER_FIELD(class, _3)
#define REGISTER_MULTI_FIELD_4(class,	_1, _2, _3, _4) REGISTER_MULTI_FIELD_3(class, _1, _2, _3) REGISTER_FIELD(class, _4) 
#define REGISTER_MULTI_FIELD_5(class,	_1, _2, _3, _4, _5) REGISTER_MULTI_FIELD_4(class, _1, _2, _3, _4)  REGISTER_FIELD(class, _5)
#define REGISTER_MULTI_FIELD_6(class,	_1, _2, _3, _4, _5, _6) REGISTER_MULTI_FIELD_5(class, _1, _2, _3, _4, _5) REGISTER_FIELD(class, _6)
#define REGISTER_MULTI_FIELD_7(class,	_1, _2, _3, _4, _5, _6, _7) REGISTER_MULTI_FIELD_6(class, _1, _2, _3, _4, _5, _6) REGISTER_FIELD(class, _7)
#define REGISTER_MULTI_FIELD_8(class,	_1, _2, _3, _4, _5, _6, _7, _8) REGISTER_MULTI_FIELD_7(class, _1, _2, _3, _4, _5, _6, _7) REGISTER_FIELD(class, _8) 
#define REGISTER_MULTI_FIELD_9(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9) REGISTER_MULTI_FIELD_8(class, _1, _2, _3, _4, _5, _6, _7, _8)  REGISTER_FIELD(class, _9) 
#define REGISTER_MULTI_FIELD_10(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) REGISTER_MULTI_FIELD_9(class, _1, _2, _3, _4, _5, _6, _7, _8, _9)  REGISTER_FIELD(class, _10) 
#define REGISTER_MULTI_FIELD_11(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) REGISTER_MULTI_FIELD_10(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10)  REGISTER_FIELD(class, _11) 
#define REGISTER_MULTI_FIELD_12(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) REGISTER_MULTI_FIELD_11(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)  REGISTER_FIELD(class, _12) 
#define REGISTER_MULTI_FIELD_13(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) REGISTER_MULTI_FIELD_12(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12)  REGISTER_FIELD(class, _13) 
#define REGISTER_MULTI_FIELD_14(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) REGISTER_MULTI_FIELD_13(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13)  REGISTER_FIELD(class, _14) 
#define REGISTER_MULTI_FIELD_15(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) REGISTER_MULTI_FIELD_14(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14)  REGISTER_FIELD(class, _15) 
#define REGISTER_MULTI_FIELD_16(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) REGISTER_MULTI_FIELD_15(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15)  REGISTER_FIELD(class, _16) 
#define REGISTER_MULTI_FIELD_17(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) REGISTER_MULTI_FIELD_16(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16)  REGISTER_FIELD(class, _17) 
#define REGISTER_MULTI_FIELD_18(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) REGISTER_MULTI_FIELD_17(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17)  REGISTER_FIELD(class, _18) 
#define REGISTER_MULTI_FIELD_19(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) REGISTER_MULTI_FIELD_18(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18)  REGISTER_FIELD(class, _19) 
#define REGISTER_MULTI_FIELD_20(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) REGISTER_MULTI_FIELD_19(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19)  REGISTER_FIELD(class, _20) 


#define REGISTER_MULTI_FUNCTION_1(class,	_1) REGISTER_INVOKE(class, _1)
#define REGISTER_MULTI_FUNCTION_2(class,	_1, _2) REGISTER_MULTI_FUNCTION_1(class, _1) REGISTER_INVOKE(class, _2)
#define REGISTER_MULTI_FUNCTION_3(class,	_1, _2, _3) REGISTER_MULTI_FUNCTION_2(class, _1, _2) REGISTER_INVOKE(class, _3)
#define REGISTER_MULTI_FUNCTION_4(class,	_1, _2, _3, _4) REGISTER_MULTI_FUNCTION_3(class, _1, _2, _3) REGISTER_INVOKE(class, _4) 
#define REGISTER_MULTI_FUNCTION_5(class,	_1, _2, _3, _4, _5) REGISTER_MULTI_FUNCTION_4(class, _1, _2, _3, _4)  REGISTER_INVOKE(class, _5)
#define REGISTER_MULTI_FUNCTION_6(class,	_1, _2, _3, _4, _5, _6) REGISTER_MULTI_FUNCTION_5(class, _1, _2, _3, _4, _5) REGISTER_INVOKE(class, _6)
#define REGISTER_MULTI_FUNCTION_7(class,	_1, _2, _3, _4, _5, _6, _7) REGISTER_MULTI_FUNCTION_6(class, _1, _2, _3, _4, _5, _6) REGISTER_INVOKE(class, _7)
#define REGISTER_MULTI_FUNCTION_8(class,	_1, _2, _3, _4, _5, _6, _7, _8) REGISTER_MULTI_FUNCTION_7(class, _1, _2, _3, _4, _5, _6, _7) REGISTER_INVOKE(class, _8) 
#define REGISTER_MULTI_FUNCTION_9(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9) REGISTER_MULTI_FUNCTION_8(class, _1, _2, _3, _4, _5, _6, _7, _8)  REGISTER_INVOKE(class, _9) 
#define REGISTER_MULTI_FUNCTION_10(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) REGISTER_MULTI_FUNCTION_9(class, _1, _2, _3, _4, _5, _6, _7, _8, _9)  REGISTER_INVOKE(class, _10) 
#define REGISTER_MULTI_FUNCTION_11(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) REGISTER_MULTI_FUNCTION_10(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10)  REGISTER_INVOKE(class, _11) 
#define REGISTER_MULTI_FUNCTION_12(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) REGISTER_MULTI_FUNCTION_11(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)  REGISTER_INVOKE(class, _12) 
#define REGISTER_MULTI_FUNCTION_13(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) REGISTER_MULTI_FUNCTION_12(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12)  REGISTER_INVOKE(class, _13) 
#define REGISTER_MULTI_FUNCTION_14(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) REGISTER_MULTI_FUNCTION_13(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13)  REGISTER_INVOKE(class, _14) 
#define REGISTER_MULTI_FUNCTION_15(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) REGISTER_MULTI_FUNCTION_14(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14)  REGISTER_INVOKE(class, _15) 
#define REGISTER_MULTI_FUNCTION_16(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) REGISTER_MULTI_FUNCTION_15(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15)  REGISTER_INVOKE(class, _16) 
#define REGISTER_MULTI_FUNCTION_17(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) REGISTER_MULTI_FUNCTION_16(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16)  REGISTER_INVOKE(class, _17) 
#define REGISTER_MULTI_FUNCTION_18(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) REGISTER_MULTI_FUNCTION_17(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17)  REGISTER_INVOKE(class, _18) 
#define REGISTER_MULTI_FUNCTION_19(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) REGISTER_MULTI_FUNCTION_18(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18)  REGISTER_INVOKE(class, _19) 
#define REGISTER_MULTI_FUNCTION_20(class,	_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) REGISTER_MULTI_FUNCTION_19(class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19)  REGISTER_INVOKE(class, _20) 


#define REFLECT_COUNT_OF_N_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, N, ...) N
#define REFLECT_COUNT_OF_N(...) REFLECT_COUNT_OF_N_IMPL(##__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

#define REFLECT_EXPAND_2(x) x
#define REFLECT_EXPAND(x) REFLECT_EXPAND_2(x)

#define REFLECT_CONTACT_2(x, y) x##y
#define REFLECT_CONTACT(x, y) REFLECT_CONTACT_2(x, y)

#define REGISTER_SUPER(class, ...) REFLECT_EXPAND(REFLECT_CONTACT(REGISTER_MULTI_SUPER_, REFLECT_COUNT_OF_N(__VA_ARGS__)))(class, __VA_ARGS__)
#define REGISTER_FIELDS(class, ...) REFLECT_EXPAND(REFLECT_CONTACT(REGISTER_MULTI_FIELD_, REFLECT_COUNT_OF_N(__VA_ARGS__)))(class, __VA_ARGS__)
#define REGISTER_INVOKES(class, ...) REFLECT_EXPAND(REFLECT_CONTACT(REGISTER_MULTI_FUNCTION_, REFLECT_COUNT_OF_N(__VA_ARGS__)))(class, __VA_ARGS__)

class REFLECT_EXPORT GenerateClassOffsetBase
{
public:
	virtual int offset()const = 0;
};

template<typename Sub, typename Base>
class GenerateClassOffset : public GenerateClassOffsetBase
{
public:
	virtual int offset() const override 
	{
		Sub sub;
		Base* base = static_cast<Base*>(&sub);
		return (char*)(base) - (char*)(dynamic_cast<Sub*>(base));
	}
};
using GenerateClassOffsetBasePtr = std::shared_ptr<GenerateClassOffsetBase>;

struct REFLECT_EXPORT SGenerateClassOffset
{
	int offset_;
	std::string name_;
};

class REFLECT_EXPORT Meta
{
public:
	static Meta* GetInstance();
	MetaObjectPtr GetMetaObject(const void* _o, const std::string& _class);
	TrdsObjectPtr NewInstance(const std::string& _class);

	void RegisterNew(const std::string& _class, const MetaFunction& newc);
	void RegisterInvoke(const std::string& _class, const MetaFunction& newc);
	void RegisterField(const std::string& _class, FieldPtr _filed);
	void RegisterSupers(const std::string& sub, std::vector<SGenerateClassOffset>& supers);
protected:

protected:
	Meta();
	Meta(const Meta&) = delete;
	Meta(Meta&&) = delete;
	Meta& operator=(const Meta&) = delete;
	Meta& operator=(Meta&&) = delete;

private:
	std::shared_ptr<MetaImpl> meta_;
};

class REFLECT_EXPORT RegisterHelper
{
public:
	RegisterHelper(const std::string& clas_, const std::string& filed_, int offset_, int size_, const SGenerateClassOffset& toTrdsOffset);
	RegisterHelper(const std::string& clas_, const MetaFunction& function, bool creator = false);
	RegisterHelper(const std::string& clas_, std::vector<SGenerateClassOffset>& supers);
};

class REFLECT_EXPORT TrdsObject
{
	OBJECT_NAME
	TRDS_RELECT(TrdsObject)
public:
	template<typename SubType>
	SubType* Dynamic_cast()
	{
		return dynamic_cast<SubType*>(this);
	}
protected:
	MetaObjectPtr metaobj_;
	std::vector<MetaObjectPtr> superObj_;
};
REGISTER_INVOKES(TrdsObject, GetObjName, SetObjName, Meta)

class REFLECT_EXPORT MetaObject
{
	friend MetaImpl;
public:
	MetaObject(void* _o, const std::string& _class, const Invokes& invokes, const Fields& fields, const News& news, const Supers& supers);
	FieldPtr GetField(int _d)const;
	FieldPtr GetField(const std::string& _d)const;
	MetaFunction GetMethod(const std::string& _d)const;
	MetaFunction GetMethod(int _d)const;
	int GetMethodCount()const;
	int GetFieldCount()const;
	std::string GetClassName()const;

protected:
	std::shared_ptr<MetaObjectImpl> meta_;
};

class REFLECT_EXPORT Field
{
public:
	std::string FieldName()const;
	int FieldSize()const;
	int Offset()const;
	std::string ClassName()const;
	TrdsObject* GetInstance()const;
	void SetValue(const Object& _val);
	Object GetValue()const;
	SGenerateClassOffset GetToTrdsOvjOffset()const;

	Field(int _offset, int size, const std::string& field, const std::string& class_, const SGenerateClassOffset& toTrdsOffset);
	Field(void* _o, int _offset, int size, const std::string& field, const std::string& class_, const SGenerateClassOffset& toTrdsOffset);

private:
	std::shared_ptr<FieldImpl> meta_;
};

//end
}
}

#endif//REFLECT_H

 2：Reflect.cpp

#include "reflect.h"
#include <algorithm>

namespace Trds {  namespace Reflect {

class REFLECT_EXPORT MetaImpl
{
public:
	MetaObjectPtr GetMetaObject(void* _o, const std::string& _class)
	{
		return MetaObjectPtr(new MetaObject(_o, _class, reflect_call, reflect_field, reflect_new, reflect_supers));
	}

	TrdsObjectPtr NewInstance(const std::string& _class)
	{
		if (reflect_new.find(_class) == reflect_new.end())
		{
			return nullptr;
		}
		TrdsObject* trds = reflect_new[_class]().Value<TrdsObject*>();
		return TrdsObjectPtr(trds);
	}

	void RegisterNew(const std::string& _class, const MetaFunction& newc)
	{
		reflect_new[_class] = newc;
	}

	void RegisterInvoke(const std::string& _class, const MetaFunction& newc)
	{
		reflect_call[_class].push_back(newc);
	}

	void RegisterField(const std::string& _class, FieldPtr _filed)
	{
		reflect_field[_class].push_back(_filed);
	}

	void RegisterSupers(const std::string& sub, std::vector<SGenerateClassOffset>& supers)
	{
			reflect_supers[sub].swap(supers);
	}

private:
	Supers		reflect_supers;
	News		reflect_new;
	Invokes		reflect_call;
	Fields		reflect_field;
};

class REFLECT_EXPORT MetaObjectImpl
{
public:
	MetaObjectImpl(void* _o, const std::string& _class, const Invokes& invokes, const Fields& fields, const News& news, const Supers& supers)
		:_o(_o),_invokes(invokes), _fields(fields),_news(news),_supers(supers), _class(_class)
	{
		/*using FieldVector = std::vector<std::shared_ptr<Field>>;
		auto pobj_ = (TrdsObject*)_o;
		Fields::const_iterator iter = _fields.find((pobj_)->GetClassName());
		if (iter != _fields.cend())
		{
			FieldVector& fields_ = const_cast<FieldVector&>(iter->second);
			std::sort(fields_.begin(), fields_.end(), [](const FieldPtr& f, const FieldPtr& s)
				{
					return f->Offset() < s->Offset();
				});
		}

		using MetaFunctionVector = std::vector<MetaFunction>;
		Invokes::const_iterator iter1 = _invokes.find(((TrdsObject*)_o)->GetClassName());
		if (iter1 != _invokes.cend())
		{
			MetaFunctionVector& metafunction_ = const_cast<MetaFunctionVector&>(iter1->second);
			std::sort(metafunction_.begin(), metafunction_.end(), [](const MetaFunction& f, const MetaFunction& s)
				{
					return f.GetLocalOffset() < s.GetLocalOffset();
				});
		}*/
	}

	TrdsObject* GetTrdsObject()const
	{
		TrdsObject* trdsobj_ = (TrdsObject*)((char*)_o + _supers.at(_class)[0].offset_);
		return trdsobj_;
	}

	std::string GetClassName()const
	{
		return  _class;
	}

	int GetMethodCount()const
	{
		if (_MethodCount == -1)
		{
			TrdsObject* trdsobj_ = GetTrdsObject();
			auto name = (trdsobj_)->GetClassName();
			for (auto pair : _invokes)
			{
				if (pair.first == name)
				{
					_MethodCount = pair.second.size();
					break;
				}
			}
		}
		return _MethodCount;
	}

	MetaFunction GetMetaFunctionOf(const std::string& class_, const std::string& method_)const
	{
		auto iter = _invokes.find(class_);
		if (iter == _invokes.end())
		{
			return MetaFunction();
		}

		auto& vct = iter->second;

		for (int i_ = 0; i_ < vct.size(); ++i_)
		{
			if (method_ == vct[i_].GetName())
			{
				return vct[i_];
			}
		}

		return MetaFunction();
	}

	MetaFunction SeekMetaFunction(const std::string& class_, const std::string& method_)const
	{
		MetaFunction result = GetMetaFunctionOf(class_, method_);

		if (result)
		{
			return result;
		}
		const auto& vect = _supers.at(class_);
		for (const auto& super : vect)
		{
			MetaFunction result = SeekMetaFunction(super.name_, method_);
			if (result)
			{
				return result;
			}
		}

		return MetaFunction();
	}

	MetaFunction GetMethod(const std::string& _d)const
	{
		TrdsObject* trdsobj_ = GetTrdsObject();
		auto name = trdsobj_->GetClassName();

		MetaFunction method_ = SeekMetaFunction(trdsobj_->GetClassName(), _d);
		if (method_)
		{
			method_.setTrdsObject(trdsobj_);
			return method_;
		}

		return MetaFunction();
	}

	MetaFunction GetMethod(int _d)const
	{
		TrdsObject* trdsobj_ = GetTrdsObject();
		auto& vect = _invokes.find(trdsobj_->GetClassName());
		if (_d >= vect->second.size())
		{
			return MetaFunction();
		}
		return vect->second[_d];
	}

	int GetFieldCount()const
	{
		if (_FieldCount == -1)
		{
			TrdsObject* trdsobj_ = GetTrdsObject();
			auto name = trdsobj_->GetClassName();
			for (auto pair : _fields)
			{
				if (pair.first == name)
				{
					_FieldCount = pair.second.size();
					break;
				}
			}
		}
		return _FieldCount;
	}

	FieldPtr GetField(int _d)const
	{
		TrdsObject* trdsobj_ = GetTrdsObject();
		auto& vect = _fields.find(trdsobj_->GetClassName());
		if (_d >= vect->second.size())
		{
			return 0;
		}
		return vect->second[_d];
	}

	struct SFlagIndexPathNode
	{
		int offset = -1;
		std::string class_ = "TrdsObject";
	};
	using SFlagIndexPath = std::vector<SFlagIndexPathNode>;

	FieldPtr GetFieldOf(const std::string& class_, const std::string& field_)const
	{
		auto iter = _fields.find(class_);
		if (iter == _fields.end())
		{
			return FieldPtr();
		}

		auto& vct = iter->second;

		for (int i_ = 0;  i_ < vct.size(); ++i_)
		{
			if (field_ == vct[i_]->FieldName())
			{
				return vct[i_];
			}
		}

		return FieldPtr();
	}

	FieldPtr SeekField(SFlagIndexPath& NodePath, const std::string& class_, const std::string& field_)const
	{
		if (class_ == "TrdsObject")
		{
			return FieldPtr();
		}
		FieldPtr resultPrt = GetFieldOf(class_, field_);

		if (resultPrt)
		{
			return resultPrt;
		}
		const auto& vect = _supers.at(class_);
		for (const auto& super : vect)
		{
			FieldPtr resultPrt = SeekField(NodePath, super.name_, field_);
			if (resultPrt)
			{
				NodePath.push_back({ super.offset_, super.name_ });
				return resultPrt;
			}
		}

		return FieldPtr();
	}

	FieldPtr GetField(const std::string& _d)const
	{
		SFlagIndexPath node_path;
		TrdsObject* trdsobj_ = GetTrdsObject();
		FieldPtr resultPrt = SeekField(node_path, trdsobj_->GetClassName(), _d);

		if (!resultPrt)
		{
			return FieldPtr();
		}

		char* obj_ = reinterpret_cast<char*>(_o);
		
		for (int i = 0; i < node_path.size(); ++i)
		{
			const SFlagIndexPathNode& node = node_path[i];
			obj_ += node.offset;
		}

		std::string name = node_path.size() > 0 ? node_path.back().class_ : trdsobj_->GetClassName();
		
		return FieldPtr(new Field(obj_, resultPrt->Offset(), resultPrt->FieldSize(), resultPrt->FieldName(), resultPrt->ClassName(), resultPrt->GetToTrdsOvjOffset()));

	}

private:
	void*			_o{ nullptr };
	const std::string	_class;
	const Supers&		_supers;
	const Invokes&		_invokes;
	const Fields&		_fields;
	const News&			_news;
	mutable int			_FieldCount = -1;
	mutable int			_MethodCount = -1;
};

class FieldImpl
{
public:
	FieldImpl(int offset_, int size_, const std::string& field_, const std::string& class_, const SGenerateClassOffset& toTrdsOffset, void* o_)
		:offset_(offset_), size_(size_), field_(field_), o_(o_), class_(class_), toTrdsObjectOffset_(toTrdsOffset)
	{

	}
	FieldImpl(int offset_, int size_, const std::string& field_, const std::string& class_, const SGenerateClassOffset& toTrdsOffset)
		:offset_(offset_), size_(size_), field_(field_), class_(class_), o_(0), toTrdsObjectOffset_(toTrdsOffset)
	{

	}

	int offset_;
	int size_;
	const std::string field_;
	const std::string class_;
	const void* o_;
	const SGenerateClassOffset toTrdsObjectOffset_;
};

Meta* Meta::GetInstance() {
	static Meta _meta;
	return &_meta;
}

MetaObjectPtr Meta::GetMetaObject(const void* _o, const std::string& _class)
{
	return meta_->GetMetaObject(const_cast<void*>(_o), _class);
}

TrdsObjectPtr Meta::NewInstance(const std::string& _class)
{
	return meta_->NewInstance(_class);
}

void Meta::RegisterNew(const std::string& _class, const MetaFunction& newc)
{
	meta_->RegisterNew(_class, newc);
}

void Meta::RegisterInvoke(const std::string& _class, const MetaFunction& newc)
{
	meta_->RegisterInvoke(_class, newc);
}

void Meta::RegisterField(const std::string& _class, FieldPtr _filed)
{
	meta_->RegisterField(_class, _filed);
}

void Meta::RegisterSupers(const std::string& sub, std::vector<SGenerateClassOffset>& supers)
{
	meta_->RegisterSupers(sub, supers);
}

Meta::Meta()
{
	meta_.reset(new MetaImpl());
}

FieldPtr MetaObject::GetField(int _d)const
{
	return meta_->GetField(_d);
}

FieldPtr MetaObject::GetField(const std::string& _d) const
{
	return meta_->GetField(_d);
}

MetaFunction MetaObject::GetMethod(const std::string& _d) const
{
	return meta_->GetMethod(_d);
}

MetaFunction MetaObject::GetMethod(int _d) const
{
	return meta_->GetMethod(_d);
}

int MetaObject::GetMethodCount() const
{
	return meta_->GetMethodCount();
}

int MetaObject::GetFieldCount() const
{
	return meta_->GetFieldCount();
}

std::string MetaObject::GetClassName() const
{
	return meta_->GetClassName();
}

MetaObject::MetaObject(void* _o, const std::string& _class, const Invokes& invokes, const Fields& fields, const News& news, const Supers& supers)
{
	meta_.reset(new MetaObjectImpl(_o, _class, invokes, fields, news, supers));

}

std::string Field::FieldName() const
{
	return meta_->field_;
}

int Field::FieldSize() const
{
	return meta_->size_;
}

int Field::Offset() const
{
	return meta_->offset_;
}

std::string Field::ClassName() const
{
	return meta_->class_;
}

TrdsObject* Field::GetInstance() const
{
	return const_cast<TrdsObject*>((TrdsObject*)((const char*)(meta_->o_) + meta_->toTrdsObjectOffset_.offset_));
}

void Field::SetValue(const Object& _val)
{
	if (!_val || _val.GetSize() != meta_->size_)
	{
		return;
	}
	const_cast<Object&>(_val).Release();
	char* ptr = const_cast<Object&>(_val).GetCharPtr();
	char* field = (char*)(meta_->o_) + meta_->offset_;
	if (_val.IsPtr())
	{
		memcpy(field, &ptr, meta_->size_);
	}
	else
	{
		memcpy(field, ptr, meta_->size_);
	}
}

Object Field::GetValue() const
{
	char* ptr = (char*)(meta_->o_) + meta_->offset_;

	auto obj =  Object(ptr, false);
	obj.SetSize(meta_->size_);

	return obj;
}

SGenerateClassOffset Field::GetToTrdsOvjOffset() const
{
	return meta_->toTrdsObjectOffset_;
}

Field::Field(void* _o, int _offset, int size, const std::string& field, const std::string& class_, const SGenerateClassOffset& toTrdsOffset)
{
	meta_.reset(new FieldImpl(_offset, size, field, class_, toTrdsOffset, _o));
}

Field::Field(int _offset, int size, const std::string& field, const std::string& class_, const SGenerateClassOffset& toTrdsOffset)
{
	meta_.reset(new FieldImpl(_offset, size, field, class_, toTrdsOffset));
}

RegisterHelper::RegisterHelper(const std::string& clas, const std::string& filed_, int offset_, int size_, const SGenerateClassOffset& toTrdsOffset)
{
	Meta::GetInstance()->RegisterField(clas, FieldPtr(new Field(offset_, size_, filed_, clas, toTrdsOffset)));
}

RegisterHelper::RegisterHelper(const std::string& clas_, const MetaFunction& function, bool creator)
{
	if (creator)
	{
		Meta::GetInstance()->RegisterNew(clas_, function);
	}
	else
	{
		Meta::GetInstance()->RegisterInvoke(clas_, function);
	}
}

RegisterHelper::RegisterHelper(const std::string& clas_, std::vector<SGenerateClassOffset>& supers)
{
	Meta::GetInstance()->RegisterSupers(clas_, supers);
}

//end
}
}

3：案例

#include <iostream>
#include "./cp_core/reflect.h"

using namespace Trds::Reflect;
class _10 { virtual void get() {} };
class _12{virtual void get() {}};
class _11{virtual void get() {}};
class _13{virtual void get() {}};
class _14{virtual void get() {}};
class _15{virtual void get() {}};
class _16 { int a = 90; virtual void get() {}};
class _17 { int a = 90; virtual void get() {}};
class _18{ virtual void get() {} };

struct CPData : public Trds::Reflect::TrdsObject,
					public _10, public _11, public _12, public _13, public _14, public _15, public _16, public _17, public _18
{
	TRDS_RELECT(CPData)

	long long a = 999;
	void* pvoid = 0;
};
REGISTER_SUPER(CPData, _10, _11, _12, _13, _14, _15, _16, _17, _18)
REGISTER_FIELDS(CPData, a, pvoid) // 需要注册多少个，你就加多少个属性，就这么简单

class CPTest :  public CPData
{
	TRDS_RELECT(CPTest)
public:
	void show(const std::string& msg)
	{
		std::cout << "msg = " << msg << std::endl;
	}

public:
	int ma = 90;
	char ch = 'a';
};
REGISTER_SUPER(CPTest, CPData)
REGISTER_FIELDS(CPTest, ma, ch) // 需要注册多少个，你就加多少个属性，就这么简单
REGISTER_INVOKES(CPTest, show)		  // 需要注册多少个，你就加多少个函数，就这么简单

int main(int argc, char** argv)
{	
	CPTest test;

	test.SetObjName("test");

	MetaObjectPtr metaPtr = test.Meta();
	FieldPtr vptr = metaPtr->GetField("a");
	FieldPtr vptrVoid = metaPtr->GetField("pvoid");
	FieldPtr maptr = metaPtr->GetField("ma");
	FieldPtr chptr = metaPtr->GetField("ch");
	vptr->SetValue((long long)0x10111213);
	auto pp = vptr->GetValue().Value<long long>();

	auto maptrint = maptr->GetValue().Value<int>();
	maptr->SetValue(987654321);
	{
		auto chvbalure = chptr->GetValue();
		auto jjj = chvbalure.Value<char>();
		chptr->SetValue('A');
	}
	void* pVoid = new CPTest;

	vptrVoid->SetValue(pVoid);

	void* vvv = vptrVoid->GetValue().Value<void*>();
	
	((CPTest*)(vvv))->a = 0X1010101010101010;

	TrdsObject* obj__ = vptr->GetInstance();
	auto anem = obj__->GetClassName();

	metaPtr->GetMethod("show")(std::string("Hello, da sha bi"));

	auto poooo =  metaPtr->GetMethod("GetObjName")();
	metaPtr->GetMethod("SetObjName")(std::string("WTF"));

	return 0; 
}

cp_frame
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入C++反射与元组
qq_33359662的博客
03-23 1132
今天就谈下c++的元组tuple，因为元组可用作反射0开销的最佳方式，所以个人认为构建元宇宙必少不了tuple元组。
C++类成员反射实现
zjjzhaohang的博客
06-14 3283
引出问题：给定一个我们自己定义的类A，如何便捷的输出其所有的成员变量类型及值。日常编程中有这样的需求，一个是为了调试，二个是为了在不同模块运行时得到类的属性用于显示及修改。但C++未提供原生的反射机制，所以有了以下思考。核心的需求为：对于一个类型A，我们可以拥有其所有的类型信息。例如： class A { int INT; float FLT; }/*MAIN*/ A a; a.IN
深入探讨C++的高级反射机制
hebhljdx的博客
06-26 2218
反射是一种编程语言能力，允许程序在运行时查询和操纵对象的类型信息。它广泛应用于对象序列化、远程过程调用、测试框架、和依赖注入等场景。 由于C++语言本身的反射能力比较弱，因此C++生态种出现了许多有趣的反射库和实现思路。我们在本文一起探讨其中的奥秘。
C++用宏实现类成员反射
leapmotion的博客
01-08 1172
这里我们使用宏来实现了结构体（或类）成员的反射，包括成员的个数，成员的指针，成员的类型。有了这些我们就可以做一些基本的操作了，比如说一些序列化结构体等等。同时我们还展示了TypeList及相关的简单操作。当然你如果需要的话，也可以将TypeList操作丰富起来。
C++反射机制：可变参数模板实现C++反射
随意的风的专栏
01-14 734
C++反射机制：可变参数模板实现C++反射 1. 概要   本文描述一个通过C++可变参数模板实现C++反射机制的方法。该方法非常实用，在Nebula高性能网络框架中大量应用，实现了非常强大的动态加载动态创建功能。   C++11的新特性--可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。关...
C++ 反射库Ponder源码剖析(1)
Runner的博客
10-24 2038
源码分析
2408C++,C++20的无侵入式反射
个人进步之路
08-08 769
2408C++,C++20的无侵入式反射
C++编译期反射实践——以AOP实现为例
CppYyds的博客
11-26 1787
自古以来，C++就一直缺少一个编程语言的重要特性——反射，但如果熟悉C++元模板编程的同学，就知道以C++的风格，肯定是不会在标准库中添加运行时的反射支持的，从最新的C++版本演进来看，倒是编译期反射可能得到更好的支持。C++11 -> C++14 -> C++17 -> C++20… 不断让元模板编程变得更简单，更规范。本次的编译期反射实践，代码要求的最低C++版本为14，因为用到了 make_shared、decay_t。本次实践的完整代码仓库：MyUtil/tree/master/aop我们如何判断某
Protocol Buffers动态自描述、反射（C++版）
赶路人儿
07-20 2688
1. 人人都爱Protocol Buffers 1.1 Protocol Buffers（PB）是什么? Protocol buffers are Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data –think XML, but smaller, ...
C++反射：深入浅出剖析ponder库实现机制！
QcloudCommunity的博客
02-22 904
导语|给静态语言添加动态特性，似乎是C++社区一件大家乐见其成的事情，轮子也非常多，我们不一一列举前辈们造的各种流派的轮子了，主要还是结合我们框架用到的C++反射实现，结合C++的新特...
C++ Qt设计模式（第2版）
01-15
第二部分讲解内存访问、继承等重要的C++特性，是前一部分的延伸和拓展；第三部分使用Phonon编写了一个多媒体播放器，展示了主要技术理念的应用方法；附录部分给出了C++保留关键字、Debian和Qt程序开发环境的配置等...
计算机图形学原理及算法教程(Visual.C++版)第二版.pdf
04-30
《计算机图形学原理及算法教程(Visual.C++版)第二版.pdf》作为一份学习资料，它的内容很可能涵盖了计算机图形学的基础理论和编程实践。Visual C++作为一种编程语言，它在实现计算机图形学相关算法上具有重要作用，...
C++反射，动态创建
whLBYX的博客
05-23 443
在 java 里有一个源生的反射机制，可以通过类的名字的字符串 动态的创建相应的类的实例化对象， 但是在 C++ 里却没有这样的机制，哎 作为 C++ 的粉，我心里顿时感觉到忧伤。难道就不行了吗？  当然是不可能！！！没有我们可以自己实现嘛！ 回想到 MFC 里的类型识别网，这里不就是动态创建的一个核心吗！恩恩稍微改改就可以了嘛！ 示意图： 大概思路：
C语言：文件（写入，读取）
2301_80311224的博客
08-21 748
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 569
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
最新发布
lly202406的博客
08-25 477
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1317
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++ 基础
weixin_51883798的博客
08-22 282
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
c语言用if语句制作点单程序
2301_81968528的博客
08-20 300
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值