【UEC++学习】反射编程基础

已于 2023-07-18 21:25:02 修改
阅读量721 收藏 14
点赞数
分类专栏： UEC++学习 文章标签： c++ 学习 虚幻 ue5
于 2023-07-18 19:24:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45617648/article/details/131786513
版权

一个类想要拥有反射的话需要包含以下内容
（1）UCLASS()前缀宏
（2）类名要加上合理的命名，如A或U
（3）对应类名合理的继承，如继承AActor或UClass
（4）加入对应的反射头文件，XXX.generated.h
（5）加入反射所对应的宏，GENERATED_BODY()

反射的调用应包含在 GENERATED_UCLASS_BODY()宏声明下，该声明下自带反射的构造函数如下：

AReflectionGameMode::AReflectionGameMode(const FObjectInitializer& ObjectInitializer) : AGameModeBase(ObjectInitializer)
{
	// 你的反射代码
}

1. 获取UClass

/** 通过创建对象获取Class */
UReflectionTestClass* TestObject = NewObject<UReflectionTestClass>();
UClass* TestClass = TestObject->GetClass();
/** 直接获取静态类 */
UClass* TestClass = UReflectionTestClass::StaticClass();

2. 获取类名

/** 获取类名 */
FName ClassName = TestClass->GetFName();

3. 获取类的成员变量

/** 获取类的成员变量 */
for(FProperty* Property = TestClass->PropertyLink; Property; Property = Property->PropertyLinkNext)
{
	// 获取成员变量的名子
	FString PropertyName = Property->GetName();
	// 获取成员变量的类型
	FString PropertyType = Property->GetCPPType();
	if(PropertyType == "FString")
	{
		// 强制转化为String
		FStrProperty* StringProperty = CastField<FStrProperty>(Property);
		// 传入某一个对象，表示获取哪一个对象的成员变量值，得到地址
		void* Addr = StringProperty->ContainerPtrToValuePtr<void>(TestObject);
		// 通过地址获取成员变量值
		FString PropertyValue = StringProperty->GetPropertyValue(Addr);
		// 获取成员变量的元数据，传入key值，这里获取的是元数据中的Category项值
		FString PropertyMetaCategory = StringProperty->GetMetaData(TEXT("Category"));
	}
}

注意：获取类属性的元数据，即获取UPROPERTY和UFUNCTION中的元数据信息，同时标记中也存在着元数据的信息。

UCLASS(Min)
class LEARNINGPROJECTV5_API UReflectionTestClass : public UObject
{
	GENERATED_BODY()

	UPROPERTY(EditAnywhere, Category = "ReflectionTestCategory")
	FString TestParam = "Nello";

	UFUNCTION(BlueprintCallable)
	void TestFuction(const FString& Input);
	
public:
	UReflectionTestClass();
	~UReflectionTestClass();
};

4. 获取类的方法

/** 获取类的方法
 * 注意：类就算没有方法也会自动生成一个可反射的方法
 */
for(TFieldIterator<UFunction> IteratorOfFunction(TestClass); IteratorOfFunction; ++IteratorOfFunction)
{
	UFunction* Function = *IteratorOfFunction;
	// 获取方法的名称
	FString FunctionName = Function->GetName();
	// 获取方法的元数据标记
	EFunctionFlags FunctionFlags = Function->FunctionFlags;
	// 获取方法的参数，会将返回值也作为参数来输出
	for(TFieldIterator<FProperty> IteratorOfParam(Function); IteratorOfParam; ++IteratorOfParam)
	{
		FProperty* Param = *IteratorOfParam;
		// 参数的名称
		FString ParamName = Param->GetName();
		// 参数的类型
		FString ParamType = Param->GetCPPType();
		// 参数的标记
		EPropertyFlags ParamFlag = Param->GetPropertyFlags(); 
	}
}

注意：
（1）类会自动生成一个可以被反射的方法。
（2）函数的标记是EFunctionFlags，结果会以位运算的方式进行各位加值，指明该函数的各种属性包含元数据等信息。
（3）参数的标记是EPropertyFlags，结果会以位运算的方式，指明该参数的各种属性，如该参数是否为返回值，以及元数据等信息。

enum EFunctionFlags : uint32
{
	// Function flags.
	FUNC_None				= 0x00000000,

	FUNC_Final				= 0x00000001,	// Function is final (prebindable, non-overridable function).
	FUNC_RequiredAPI		= 0x00000002,	// Indicates this function is DLL exported/imported.
	FUNC_BlueprintAuthorityOnly= 0x00000004,   // Function will only run if the object has network authority
	FUNC_BlueprintCosmetic	= 0x00000008,   // Function is cosmetic in nature and should not be invoked on dedicated servers
	// FUNC_				= 0x00000010,   // unused.
	// FUNC_				= 0x00000020,   // unused.
	FUNC_Net				= 0x00000040,   // Function is network-replicated.
	FUNC_NetReliable		= 0x00000080,   // Function should be sent reliably on the network.
	FUNC_NetRequest			= 0x00000100,	// Function is sent to a net service
	FUNC_Exec				= 0x00000200,	// Executable from command line.
	FUNC_Native				= 0x00000400,	// Native function.
	FUNC_Event				= 0x00000800,   // Event function.
	FUNC_NetResponse		= 0x00001000,   // Function response from a net service
	FUNC_Static				= 0x00002000,   // Static function.
	FUNC_NetMulticast		= 0x00004000,	// Function is networked multicast Server -> All Clients
	FUNC_UbergraphFunction	= 0x00008000,   // Function is used as the merge 'ubergraph' for a blueprint, only assigned when using the persistent 'ubergraph' frame
	FUNC_MulticastDelegate	= 0x00010000,	// Function is a multi-cast delegate signature (also requires FUNC_Delegate to be set!)
	FUNC_Public				= 0x00020000,	// Function is accessible in all classes (if overridden, parameters must remain unchanged).
	FUNC_Private			= 0x00040000,	// Function is accessible only in the class it is defined in (cannot be overridden, but function name may be reused in subclasses.  IOW: if overridden, parameters don't need to match, and Super.Func() cannot be accessed since it's private.)
	FUNC_Protected			= 0x00080000,	// Function is accessible only in the class it is defined in and subclasses (if overridden, parameters much remain unchanged).
	FUNC_Delegate			= 0x00100000,	// Function is delegate signature (either single-cast or multi-cast, depending on whether FUNC_MulticastDelegate is set.)
	FUNC_NetServer			= 0x00200000,	// Function is executed on servers (set by replication code if passes check)
	FUNC_HasOutParms		= 0x00400000,	// function has out (pass by reference) parameters
	FUNC_HasDefaults		= 0x00800000,	// function has structs that contain defaults
	FUNC_NetClient			= 0x01000000,	// function is executed on clients
	FUNC_DLLImport			= 0x02000000,	// function is imported from a DLL
	FUNC_BlueprintCallable	= 0x04000000,	// function can be called from blueprint code
	FUNC_BlueprintEvent		= 0x08000000,	// function can be overridden/implemented from a blueprint
	FUNC_BlueprintPure		= 0x10000000,	// function can be called from blueprint code, and is also pure (produces no side effects). If you set this, you should set FUNC_BlueprintCallable as well.
	FUNC_EditorOnly			= 0x20000000,	// function can only be called from an editor scrippt.
	FUNC_Const				= 0x40000000,	// function can be called from blueprint code, and only reads state (never writes state)
	FUNC_NetValidate		= 0x80000000,	// function must supply a _Validate implementation

	FUNC_AllFlags		= 0xFFFFFFFF,
};

enum EPropertyFlags : uint64
{
	CPF_None = 0,

	CPF_Edit							= 0x0000000000000001,	///< Property is user-settable in the editor.
	CPF_ConstParm						= 0x0000000000000002,	///< This is a constant function parameter
	CPF_BlueprintVisible				= 0x0000000000000004,	///< This property can be read by blueprint code
	CPF_ExportObject					= 0x0000000000000008,	///< Object can be exported with actor.
	CPF_BlueprintReadOnly				= 0x0000000000000010,	///< This property cannot be modified by blueprint code
	CPF_Net								= 0x0000000000000020,	///< Property is relevant to network replication.
	CPF_EditFixedSize					= 0x0000000000000040,	///< Indicates that elements of an array can be modified, but its size cannot be changed.
	CPF_Parm							= 0x0000000000000080,	///< Function/When call parameter.
	CPF_OutParm							= 0x0000000000000100,	///< Value is copied out after function call.
	CPF_ZeroConstructor					= 0x0000000000000200,	///< memset is fine for construction
	CPF_ReturnParm						= 0x0000000000000400,	///< Return value.
	CPF_DisableEditOnTemplate			= 0x0000000000000800,	///< Disable editing of this property on an archetype/sub-blueprint
	CPF_NonNullable						= 0x0000000000001000,	///< Object property can never be null
	CPF_Transient   					= 0x0000000000002000,	///< Property is transient: shouldn't be saved or loaded, except for Blueprint CDOs.
	CPF_Config      					= 0x0000000000004000,	///< Property should be loaded/saved as permanent profile.
	//CPF_								= 0x0000000000008000,	///< 
	CPF_DisableEditOnInstance			= 0x0000000000010000,	///< Disable editing on an instance of this class
	CPF_EditConst   					= 0x0000000000020000,	///< Property is uneditable in the editor.
	CPF_GlobalConfig					= 0x0000000000040000,	///< Load config from base class, not subclass.
	CPF_InstancedReference				= 0x0000000000080000,	///< Property is a component references.
	//CPF_								= 0x0000000000100000,	///<
	CPF_DuplicateTransient				= 0x0000000000200000,	///< Property should always be reset to the default value during any type of duplication (copy/paste, binary duplication, etc.)
	//CPF_								= 0x0000000000400000,	///< 
	//CPF_    							= 0x0000000000800000,	///< 
	CPF_SaveGame						= 0x0000000001000000,	///< Property should be serialized for save games, this is only checked for game-specific archives with ArIsSaveGame
	CPF_NoClear							= 0x0000000002000000,	///< Hide clear (and browse) button.
	//CPF_  							= 0x0000000004000000,	///<
	CPF_ReferenceParm					= 0x0000000008000000,	///< Value is passed by reference; CPF_OutParam and CPF_Param should also be set.
	CPF_BlueprintAssignable				= 0x0000000010000000,	///< MC Delegates only.  Property should be exposed for assigning in blueprint code
	CPF_Deprecated  					= 0x0000000020000000,	///< Property is deprecated.  Read it from an archive, but don't save it.
	CPF_IsPlainOldData					= 0x0000000040000000,	///< If this is set, then the property can be memcopied instead of CopyCompleteValue / CopySingleValue
	CPF_RepSkip							= 0x0000000080000000,	///< Not replicated. For non replicated properties in replicated structs 
	CPF_RepNotify						= 0x0000000100000000,	///< Notify actors when a property is replicated
	CPF_Interp							= 0x0000000200000000,	///< interpolatable property for use with cinematics
	CPF_NonTransactional				= 0x0000000400000000,	///< Property isn't transacted
	CPF_EditorOnly						= 0x0000000800000000,	///< Property should only be loaded in the editor
	CPF_NoDestructor					= 0x0000001000000000,	///< No destructor
	//CPF_								= 0x0000002000000000,	///<
	CPF_AutoWeak						= 0x0000004000000000,	///< Only used for weak pointers, means the export type is autoweak
	CPF_ContainsInstancedReference		= 0x0000008000000000,	///< Property contains component references.
	CPF_AssetRegistrySearchable			= 0x0000010000000000,	///< asset instances will add properties with this flag to the asset registry automatically
	CPF_SimpleDisplay					= 0x0000020000000000,	///< The property is visible by default in the editor details view
	CPF_AdvancedDisplay					= 0x0000040000000000,	///< The property is advanced and not visible by default in the editor details view
	CPF_Protected						= 0x0000080000000000,	///< property is protected from the perspective of script
	CPF_BlueprintCallable				= 0x0000100000000000,	///< MC Delegates only.  Property should be exposed for calling in blueprint code
	CPF_BlueprintAuthorityOnly			= 0x0000200000000000,	///< MC Delegates only.  This delegate accepts (only in blueprint) only events with BlueprintAuthorityOnly.
	CPF_TextExportTransient				= 0x0000400000000000,	///< Property shouldn't be exported to text format (e.g. copy/paste)
	CPF_NonPIEDuplicateTransient		= 0x0000800000000000,	///< Property should only be copied in PIE
	CPF_ExposeOnSpawn					= 0x0001000000000000,	///< Property is exposed on spawn
	CPF_PersistentInstance				= 0x0002000000000000,	///< A object referenced by the property is duplicated like a component. (Each actor should have an own instance.)
	CPF_UObjectWrapper					= 0x0004000000000000,	///< Property was parsed as a wrapper class like TSubclassOf<T>, FScriptInterface etc., rather than a USomething*
	CPF_HasGetValueTypeHash				= 0x0008000000000000,	///< This property can generate a meaningful hash value.
	CPF_NativeAccessSpecifierPublic		= 0x0010000000000000,	///< Public native access specifier
	CPF_NativeAccessSpecifierProtected	= 0x0020000000000000,	///< Protected native access specifier
	CPF_NativeAccessSpecifierPrivate	= 0x0040000000000000,	///< Private native access specifier
	CPF_SkipSerialization				= 0x0080000000000000,	///< Property shouldn't be serialized, can still be exported to text
};

5. 获取类的标记

/** 获取类的标记 */
EClassFlags ClassFlags = TestClass->ClassFlags;
// 判断是否存在某一标记
bool ClassHasConfigFlag = TestClass->HasAnyClassFlags(EClassFlags::CLASS_Config);

enum EClassFlags
{
	/** No Flags */
	CLASS_None				  = 0x00000000u,
	/** Class is abstract and can't be instantiated directly. */
	CLASS_Abstract            = 0x00000001u,
	/** Save object configuration only to Default INIs, never to local INIs. Must be combined with CLASS_Config */
	CLASS_DefaultConfig		  = 0x00000002u,
	/** Load object configuration at construction time. */
	CLASS_Config			  = 0x00000004u,
	/** This object type can't be saved; null it out at save time. */
	CLASS_Transient			  = 0x00000008u,
	/** This object type may not be available in certain context. (i.e. game runtime or in certain configuration). Optional class data is saved separately to other object types. (i.e. might use sidecar files) */
	CLASS_Optional            = 0x00000010u,
	/** */
	CLASS_MatchedSerializers  = 0x00000020u,
	/** Indicates that the config settings for this class will be saved to Project/User*.ini (similar to CLASS_GlobalUserConfig) */
	CLASS_ProjectUserConfig	  = 0x00000040u,
	/** Class is a native class - native interfaces will have CLASS_Native set, but not RF_MarkAsNative */
	CLASS_Native			  = 0x00000080u,
	/** Don't export to C++ header. */
	CLASS_NoExport UE_DEPRECATED(5.1, "CLASS_NoExport should no longer be used. It is no longer being set by engine code.") = 0x00000100u,
	/** Do not allow users to create in the editor. */
	CLASS_NotPlaceable        = 0x00000200u,
	/** Handle object configuration on a per-object basis, rather than per-class. */
	CLASS_PerObjectConfig     = 0x00000400u,
	
	/** Whether SetUpRuntimeReplicationData still needs to be called for this class */
	CLASS_ReplicationDataIsSetUp = 0x00000800u,
	
	/** Class can be constructed from editinline New button. */
	CLASS_EditInlineNew		  = 0x00001000u,
	/** Display properties in the editor without using categories. */
	CLASS_CollapseCategories  = 0x00002000u,
	/** Class is an interface **/
	CLASS_Interface           = 0x00004000u,
	/**  Do not export a constructor for this class, assuming it is in the cpptext **/
	CLASS_CustomConstructor UE_DEPRECATED(5.1, "CLASS_CustomConstructor should no longer be used. It is no longer being set by engine code.") = 0x00008000u,
	/** all properties and functions in this class are const and should be exported as const */
	CLASS_Const			      = 0x00010000u,

	/** Class flag indicating objects of this class need deferred dependency loading */
	CLASS_NeedsDeferredDependencyLoading = 0x00020000u,
	
	/** Indicates that the class was created from blueprint source material */
	CLASS_CompiledFromBlueprint  = 0x00040000u,

	/** Indicates that only the bare minimum bits of this class should be DLL exported/imported */
	CLASS_MinimalAPI	      = 0x00080000u,
	
	/** Indicates this class must be DLL exported/imported (along with all of it's members) */
	CLASS_RequiredAPI	      = 0x00100000u,

	/** Indicates that references to this class default to instanced. Used to be subclasses of UComponent, but now can be any UObject */
	CLASS_DefaultToInstanced  = 0x00200000u,

	/** Indicates that the parent token stream has been merged with ours. */
	CLASS_TokenStreamAssembled  = 0x00400000u,
	/** Class has component properties. */
	CLASS_HasInstancedReference= 0x00800000u,
	/** Don't show this class in the editor class browser or edit inline new menus. */
	CLASS_Hidden			  = 0x01000000u,
	/** Don't save objects of this class when serializing */
	CLASS_Deprecated		  = 0x02000000u,
	/** Class not shown in editor drop down for class selection */
	CLASS_HideDropDown		  = 0x04000000u,
	/** Class settings are saved to <AppData>/..../Blah.ini (as opposed to CLASS_DefaultConfig) */
	CLASS_GlobalUserConfig	  = 0x08000000u,
	/** Class was declared directly in C++ and has no boilerplate generated by UnrealHeaderTool */
	CLASS_Intrinsic			  = 0x10000000u,
	/** Class has already been constructed (maybe in a previous DLL version before hot-reload). */
	CLASS_Constructed		  = 0x20000000u,
	/** Indicates that object configuration will not check against ini base/defaults when serialized */
	CLASS_ConfigDoNotCheckDefaults = 0x40000000u,
	/** Class has been consigned to oblivion as part of a blueprint recompile, and a newer version currently exists. */
	CLASS_NewerVersionExists  = 0x80000000u,
};

总结：
（1）获取标记得到的是位运算之和，标记中不止含有元数据的值，还有各类标明属性的值。
（2）无论是属性标记、函数标记、类标记，都可以通过HasAnyClassFlags进行快速判断是否含有某一标记。

6. 获取类的父子类

/** 获取类的父类的名称 */
UClass* ParentClass = TestObject->GetClass()->GetSuperClass();
FString ParentClassName = ParentClass->GetName();

/** 判断一个类是否是另一个类的子类 */
// 获取静态类
UClass* Class1 = UReflectionTestClass::StaticClass();
UClass* Class2 = UObject::StaticClass();
// 判断 Class1 是否是 Class2 的孩子
if(Class1->IsChildOf(Class2))
{
	
}

/** 获取特定类的所有子类 */
TArray<UClass*> ChildOfClassResults;
// 第一个参数：传入要查找类的子类的该类；第二个参数：接受返回的数组；第三个参数：是否循环迭代，即是否查找子类的子类
GetDerivedClasses(UReflectionTestClass::StaticClass(), ChildOfClassResults, false);

7. 获取类生成的所有对象

/** 获取特定类生成的所有对象 */
TArray<UObject*> ObjectOfClassResults;
// 第一个参数：传入要查找类的对象的该类；第二个参数：接受返回的数组
GetObjectsOfClass(UReflectionTestClass::StaticClass(), ObjectOfClassResults, false);

8. 根据名称查找相应的类/方法

/** 根据给定字符串查找相应的类 */
// 通过名字查找类的时候不要加名称前缀，A/U等
UClass* ClassByStringName = FindObject<UClass>(ANY_PACKAGE, *FString("ReflectionTestClass"), true);
/** 根据给定字符串查找相应的枚举 */
UEnum* EnumByStringName = FindObject<UEnum>(ANY_PACKAGE, *FString("ReflectionTestEnum"), true);
/** 根据给定字符串查找相应的蓝图类, 注意该蓝图类需要继承自UObject */
UBlueprint* BlueprintByStringName = FindObject<UBlueprint>(ANY_PACKAGE, *FString("BP_ReflectionTestBlueprint"), true);
/** 根据给定字符串查找相应的类的成员函数，EIncludeSuperFlag::ExcludeSuper表示不查找父类 */
UFunction* FindFunctionByStringName = 
	UReflectionTestClass::StaticClass()->FindFunctionByName(TEXT("TestFuction"), EIncludeSuperFlag::ExcludeSuper);

注意：
（1）查找时使用的字符串不用添加U/A等前缀。
（2）查找的类和函数一定具有反射标记

9. 获取枚举中的项名称

/** 查找枚举下的所有项
 * 注意：枚举会自动增加一个项：枚举名_MAX
 */
if(EnumByStringName)
{
	for(int32 i = 0; i < EnumByStringName->NumEnums(); i++)
	{
		FString FindEnumItemName = EnumByStringName->GetNameStringByIndex(i);
	}
}

10. 调用类的方法

通过反射使用ProcessEvent()调用类的方法

/** 使用ProcessEvent调用类的成员方法 */
UReflectionTestClass* Object = NewObject<UReflectionTestClass>();
UFunction* Function = 
	UReflectionTestClass::StaticClass()->FindFunctionByName(TEXT("TestFuction"), EIncludeSuperFlag::ExcludeSuper);
if(Function)
{
	// 1. 给所有方法参数分配空间并初始化为0
	uint8* FunctionParamMemory = static_cast<uint8*>(FMemory_Alloca(Function->ParmsSize));
	FMemory::Memzero(FunctionParamMemory, Function->ParmsSize);
	// 2. 给所有方法参数赋值
	for(TFieldIterator<FProperty> IteratorOfParam(Function); IteratorOfParam; ++IteratorOfParam)
	{
		FProperty* Param = *IteratorOfParam;
		FString FunctionParamName = Param->GetName();
		// 通过参数名找到该传入参数
		if(FunctionParamName == FString("Input"))
		{
			// 设置传入参数的值
			*Param->ContainerPtrToValuePtr<FString>(FunctionParamMemory) = "One";
		}
	}
	// 3. 通过ProcessEvent调用方法
	Object->ProcessEvent(Function, FunctionParamMemory);
}

通过反射使用Invoke()调用类的方法

/** 使用Invoke调用类的成员方法 */
UReflectionTestClass* Object = NewObject<UReflectionTestClass>();
UFunction* Function = 
	UReflectionTestClass::StaticClass()->FindFunctionByName(TEXT("TestFuction"), EIncludeSuperFlag::ExcludeSuper);
if(Function)
{
	// 1. 给所有方法参数分配空间并初始化为0
	uint8* FunctionParamMemory = static_cast<uint8*>(FMemory_Alloca(Function->ParmsSize));
	FMemory::Memzero(FunctionParamMemory, Function->ParmsSize);
	// 2. 创建一个Frame
	FFrame Frame(nullptr, Function, &FunctionParamMemory);
	// 3. 调用Invoke，第一个参数：调用方法的对象；第二个参数：Frame；第三个参数：为返回值，没有返回值就设为nullptr
	Function->Invoke(Object, Frame, nullptr);
}

11. 遍历所有类

/** 遍历所有的类 */
for(TObjectIterator<UClass> ClassIterator; ClassIterator; ++ClassIterator)
{
	FString ClassName = ClassIterator->GetName();
}
浮沉丶奕辻琮
关注
专栏目录
UEC++实时音频播放插件支持win64和Linux平台
07-03
可以加载文件中的音频文件进行播放，支持wav.MP3等常用的格式。开发这个插件的时候是UE的5.2版本但是使用的UEC++语言编写如果代码兼容没问题理论上是低版本和高版本通用。
UE4反射宏简单整理（时不时更新）
weixin_49080541的博客
02-28 493
摘自UE4 反射系统详细剖析 反射宏名称 作用 UCLASS 告诉UE这个类是一个反射类。类必须派生自UObject USTRUCT 可以不用派生自UObject。不支持GC，也不能包含函数 UPROPERTY 定义一个反射的变量 UFUNCTION 定义一个反射的函数 UENUM 告诉UE这是一个反射的枚举类。支持enum, enum class, enum namespace UINTERFACE 定义一个反射接口类，只能包含函数 UMETA 反射的一些元数据定义
UE4 C++反射从入门到原理剖解(UE4 4.26)
qq_29523119的博客
08-05 5575
UE4 C++反射具体应用案例 测试反射类ATestActor // Fill out your copyright notice in the Description page of Project Settings. #pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "TestActor.generated.h" UCLASS(Blueprintable, meta = (Dis..
UE4/5C++之关于UCLASS()的说明符和元数据修饰符
多方通行8的博客
04-06 1242
抽象类说明符将类声明为 “抽象基类”, 防止用户在虚幻编辑器中向世界添加此类的参与者, 或在游戏中创建此类的实例。这对于那些本身没有意义的类很有用。例如, ATriggerBase 基类是抽象的, 而 ATriggerBox 子类别不是抽象的, 您可以在世界上放置一个 ATriggerBox 类的实例, 并且它是有用的, 而 ATriggerBase 的实例本身并不有用。
【UE4 反射系统】 UCLAS UFUNCTION UPROPERTY 宏简单解析 持续更新
hhw_hhw的博客
10-18 844
文章作者技术和水平有限，如果文中出现错误，希望大家能指正，同时有问题的话，欢迎大家留言讨论。
[UE4] UCLASSES 类说明符-UClasses
iDaDi的博客
03-29 567
https://docs.unrealengine.com/zh-CN/ProgrammingAndScripting/GameplayArchitecture/Classes/Specifiers/index.html 类说明符 关键词，用于在声明UClasses时指定类相对于引擎和编辑器的各个方面的行为。 声明类时，可以为声明添加类说明符，以控制类相对于引擎和编辑器的各个方面的行为。 类说明符 效果 Abstract ...
UEC++INI读取配置文件
qq_29891697的博客
07-26 953
1.在DefaultGame.ini添加，表示打包不包含到pak文件中(MyProject=项目名)例：[[Staging]
从0创建蓝图编辑器(源码+思维导图)
12-22
在本文中，我们将深入探讨如何从零开始创建一个蓝图编辑器，主要基于Unreal Engine 4（UE4）的C++源码，并结合思维导图进行设计...这个过程中，我们将深入理解UE4的架构，增强C++编程技能，以及掌握图形化编程的精髓。
C8051F020编程器UEC5驱动
02-06
C8051F020编程器UEC5驱动是一款专为Silicon Labs的C8051F020微控制器设计的编程工具的驱动程序。C8051F020是一款高性能、低功耗的8051内核微控制器，广泛应用于嵌入式系统设计，如工业控制、消费电子和医疗设备等...
C++的cast强制类型转换
12-02
在C++编程中，类型转换是一项基本而又关键的技术，尤其在处理复杂数据结构和类层次结构时。C++提供了多种类型转换方式，包括`static_cast`、`dynamic_cast`、`const_cast`以及`reinterpret_cast`。本文将重点探讨`...
geojson-cpp:C ++ 14库，用于将GeoJSON转换为geometry.hpp表示形式
05-05
在C++编程中，处理GeoJSON数据通常需要专门的库来解析和操作这些数据。"geojson-cpp"就是这样一个库，专为C++14设计，用于将GeoJSON数据转换成可由`geometry.hpp`表示的形式。 `geometry.hpp`通常是一个头文件，...
【UE 反射】反射的原理是什么？如何使用机制？
最新发布
hhw_hhw的博客
05-29 2650
静态类型检查确保了类型的早期一致性和高效的代码执行，但减少了灵活性。动态类型检查提供了更大的灵活性，但增加了运行时的开销和潜在的错误。反射作为一种动态特性，无论是在静态类型语言还是动态类型语言中，都提供了强大的运行时类型操作能力，但也伴随着性能和安全性方面的权衡。通过理解这些联系，开发者可以在不同的编程语言和应用场景中选择适合的类型检查方式和反射机制，以实现所需的动态行为和灵活性，同时保证性能和安全性。
UE4基础总结
GIS探索之路
02-25 8377
Actor的EndPlay事件在哪些时候会调用？ 对 Destroy 显式调用 Play in Editor 终结 关卡过渡（无缝行程或加载地图） 包含 Actor 的流关卡被卸载 Actor 的生命期已过 应用程序关闭（全部 Actor 被销毁） 游戏结束 见：Actor生命周期 BlueprintImplementableEvent和BlueprintNativeEvent之间有什...
UE4入门-常见的宏-UCLASS
热门推荐
303snowing
11-21 1万+
UCLASS 宏为 UObject 提供一个对 UCLASS 的引用，描述其基于虚幻引擎的类型。每个 UCLASS 保留一个称作“类默认对象（Class Default Object）”的对象，简称 CDO。CDO 本质上是一个默认“模板”对象，由类构建函数生成，之后并未进行修改。UCLASS 和 CDO 均可为特定对象实例恢复，但它们通常为只读。使用 GetClass() 函数即可随时访问对象实例
UE5中使用反射系统进行结构体字段值的获取与设置（c++编写、蓝图调用）
u010804261的博客
02-29 1017
但是因为字段量级太大，同时重复性工作非常多，并且这些字段可能还会随时增加，如果依旧采用传统方式，就会导致每次新增时，都要新增代码。最近在做一个数字孪生项目，需要大量的接收上游的数据显示到程序界面上，同时程序也会给上游反馈数据，比如一个按钮，按下时，给上游反馈1，松开后反馈0.这样，每次结构体有变化时，只需要修改结构体，其他字段的更新与获取无需任何改变。整体调用的方式为，c++中编写反射脚本，传入字段名可获取对应字段值与设置对应字段值，在蓝图中可调用该方法，并传入字段名。
UE4 C++ 利用反射获取到类、类的成员
qq_40026009的博客
03-26 1万+
一、获取到特定类的对象实例 1.1、GetObjectsOfClass GetObjectsOfClass(类型::GetStaticClass(),存储结果的数组); TArray<UObject*> Objs; GetObjectsOfClass(UClass::StaticClass(), Objs); TArray<UObject*> ActorObjs; ...
UE 泛型蓝图
qq_29891697的博客
07-26 331
【代码】UE 泛型蓝图。
【UE】使用FindFProperty查找对象中的属性
weixin_51638732的博客
12-21 468
使用FindFProperty查找对象中的属性
UE的反射--使UC++中定义变量和函数等属性可以在蓝图中使用
yuemuc的博客
10-30 281
解决刚接触UC++的同学对于反射和宏的疑惑和了解其基本使用
uec++ 正则表达式
01-06
UEC++正则表达式是用于在UEC++代码中匹配和提取特定模式的工具。它可以帮助您在代码中查找和操作字符串。下面是一个演示UEC++正则表达式的例子： 假设我们有以下UEC++代码片段： ```cpp #include <iostream> #include <regex> int main() { std::string input = "Hello World! This is UEC++."; std::regex pattern("UEC\\+\\+"); std::smatch matches; if (std::regex_search(input, matches, pattern)) { std::cout << "Match found: " << matches[0] << std::endl; } else { std::cout << "No match found." << std::endl; } return 0; } ``` 这个例子中，我们使用`std::regex`类来创建一个正则表达式模式，该模式用于匹配字符串中的"UEC++"。然后，我们使用`std::regex_search`函数来搜索输入字符串，并将匹配的结果存储在`std::smatch`对象中。如果找到匹配项，我们将打印出匹配的结果。 运行上述代码，输出将是： ``` Match found: UEC++ ``` 这表明我们成功地找到了字符串中的"UEC++"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值