UE4中的反射之一:编译阶段

环境

引擎版本: github 4.20

参考文章

有关反射的材料看以下几个就够了,如果你看了还不理解的话,那再看其它材料估计也没什么用,你可能需要先使用一段时间虚幻4引擎,然后再返回头来继续看

简介

UE4 中的反射大概的流程是在编译前利用 UnrealHeaderTool 对代码文件内容进行处理,生成 .generated.h/.gen.cpp 文件,在生成的代码中加入反射信息,并和自己编写的代码一起编译,在运行时动态地将这些反射信息收集起来使用。

UnrealHeaderTool 预处理

我们编写代码过程中用到的 UCLASS UFUNCTION UPROPERTY 这些宏就是参与这个阶段,当 UHT 处理代码时,遇到这些宏标记,就知道接下来的代码需要进行处理,具体怎么处理根据宏类型不同而不同,具体就不展开了

UCLASS UFUNCTION UPROPERTY 这些宏在之后的 C++ 编译器编译过程中的预处理中,都会被展开,只不过展开的内容是空的,所以这些宏只是作为 UHT 阶段的代码处理标记使用,不会影响到真正的编译

C++编译器编译代码预处理阶段

这个阶段对我们来说最重要的就是理解 GENERATED_BODY/GENERATED_USTRUCT_BODY/GENERATED_UCLASS_BODY/GENERATED_UINTERFACE_BODY/GENERATED_IINTERFACE_BODY 展开的结果

这些宏定义在 Objectmacros.h 文件中,具体定义如下

1
2
3
4
5
6
7
#define GENERATED_BODY_LEGACY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY);
#define GENERATED_BODY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY);

#define GENERATED_USTRUCT_BODY(...) GENERATED_BODY()
#define GENERATED_UCLASS_BODY(...) GENERATED_BODY_LEGACY()
#define GENERATED_UINTERFACE_BODY(...) GENERATED_BODY_LEGACY()
#define GENERATED_IINTERFACE_BODY(...) GENERATED_BODY_LEGACY()

从上面定义可以看出 GENERATED_BODY/GENERATED_USTRUCT_BODY 是一致的,其他宏也是一样,最终两个关键的宏是 GENERATED_BODY/GENERATED_BODY_LEGACY,这两个宏展开后都是由三个内容组成,第一部分是 CURRENT_FILE_ID 这个宏展开后的内容,第二部分是当前行号,第三部分是 GENERATED_BODY/GENERATED_BODY_LEGACY 字符串,三个部分间用 _ 号相连,其中最重要的是第一部分 CURRENT_FILE_ID,这个宏定义在 UHT 生成的代码 xx.generated.h 中,被定义为当前文件相对于工程根目录的路径,保证唯一。这也是为什么我们要包含 xx.generated.h 的原因,一是让 UHT 知道它需要处理这个头文件,二是因为在 C++ 编译器编译过程中需要这个文件里定义的宏

现在我们有一个类,内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// ...
#include "MyActor.generated.h"

UCLASS()
class TESTCALL_API AMyActor : public AActor
{
GENERATED_BODY()

public:
UFUNCTION(BlueprintImplementableEvent)
void MyActorBlueprintImplementableEvent();

UFUNCTION(BlueprintNativeEvent)
void MyActorBlueprintNativeEvent();

UFUNCTION(BlueprintPure)
int32 MyActorBlueprintPure();

UFUNCTION(BlueprintCallable)
void MyActorBlueprintCallable();

UFUNCTION(BlueprintGetter)
int32 MyActorBlueprintGetter();

UFUNCTION(BlueprintSetter)
void MyActorBlueprintSetter(int32 Test);

UPROPERTY()
int MyActorProperty;
};

GENERATED_BODY 宏展开的过程如下

1
2
3
4
5
6
7
GENERATED_BODY
-> (CURRENT_FILE_ID)_(__LINE__)_GENERATED_BODY
-> TestCall_Source_TestCall_MyActor_h_12_GENERATED_BODY

GENERATED_UCLASS_BODY
-> (CURRENT_FILE_ID)_(__LINE__)_GENERATED_BODY_LEGACY
-> TestCall_Source_TestCall_MyActor_h_12_GENERATED_BODY_LEGACY

展开到上面的结果后,得到的完整宏就定义在 MyActor.generated.h 文件中,所以上面的类定义代码就等价于

1
2
3
4
class TESTCALL_API AMyActor : public AActor
{
TestCall_Source_TestCall_MyActor_h_12_GENERATED_BODY
};

上面的结果还是一个宏,继续展开,从 MyActor.generated.h 可以看到,这个宏的定义如下

1
2
3
4
5
6
7
8
9
10
#define TestCall_Source_TestCall_MyActor_h_12_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
TestCall_Source_TestCall_MyActor_h_12_PRIVATE_PROPERTY_OFFSET \
TestCall_Source_TestCall_MyActor_h_12_RPC_WRAPPERS_NO_PURE_DECLS \
TestCall_Source_TestCall_MyActor_h_12_CALLBACK_WRAPPERS \
TestCall_Source_TestCall_MyActor_h_12_INCLASS_NO_PURE_DECLS \
TestCall_Source_TestCall_MyActor_h_12_ENHANCED_CONSTRUCTORS \
private: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS

PRAGMA_DISABLE_DEPRECATION_WARNINGS/PRAGMA_ENABLE_DEPRECATION_WARNINGS

这两个宏是用来开启/关闭禁止编译器过期警告

TestCall_Source_TestCall_MyActor_h_12_PRIVATE_PROPERTY_OFFSET

这个宏是空内容

TestCall_Source_TestCall_MyActor_h_12_RPC_WRAPPERS_NO_PURE_DECLS

这个宏里的内容是用来展开我们之前定义的 UFUNCTION,具体内如如下

  • UFUNCTION(BlueprintImplementableEvent) 这种函数是实现在蓝图中的,由 C++ 进行调用,所以在 .generated.h 中没有相应的实现

  • UFUNCTION(BlueprintNativeEvent) 这种函数蓝图可以进行重写,C++ 中有一份默认实现,由 C++ 进行调用,如果蓝图没有重写,那么就调用 C++ 版本的实现,可以看到在 .generated.h 中对这种函数声明了一个 _Implementation 结尾的函数,所以需要在 cpp 中相应的实现 _Implementation 结尾的函数。同时还对这个函数实现了一个带 exec 前缀的版本,这个版本内部调用了 _Implementation 后缀的版本。因为当 C++ 直接调用,或者蓝图的实现中调用 C++ 默认版本(类似 C++ 虚函数的重载时,经常会调用一下父类版本),都会先调用这个 exec 版本中,最终调用到 _Implementation 后缀的版本。

  • 其他的 BlueprintSetter/BlueprintGetter/BlueprintCallable/BlueprintPure,这些都会生成一个 exec 前缀的版本,在这个版本的函数里直接调用了 C++ 版本

上面介绍中的 exec 版本函数是由 DECLARE_FUNCTION 这个宏来展开,这个宏定义如下

1
2
3
4
5

#define RESULT_PARAM Z_Param__Result
#define RESULT_DECL void*const RESULT_PARAM

#define DECLARE_FUNCTION(func) static void func( UObject* Context, FFrame& Stack, RESULT_DECL )

可见这些类成员函数最终会对应一个 exec 版本的静态成员函数,具体展开结果如下

1
2
3
4
5
6
7
8
9
10
11
static void execMyActorBlueprintNativeEvent( UObject* Context, FFrame& Stack, void*const Z_Param__Result )
{
Stack.Code += !!Stack.Code;

{
SCOPED_SCRIPT_NATIVE_TIMER(ScopedNativeCallTimer);

// ThisClass 是个 typedef, 是在后面的宏里定义的,在这里就是 AMyAcotr
((ThisClass*)(Context))->MyActorBlueprintNativeEvent_Implementation();
}
}

TestCall_Source_TestCall_MyActor_h_12_CALLBACK_WRAPPERS

这个宏也是个空宏

TestCall_Source_TestCall_MyActor_h_12_INCLASS

这个宏定义如下

1
2
3
4
5
6
7
#define TestCall_Source_TestCall_MyActor_h_12_INCLASS \
private: \
static void StaticRegisterNativesAMyActor(); \
friend struct Z_Construct_UClass_AMyActor_Statics; \
public: \
DECLARE_CLASS(AMyActor, AActor, COMPILED_IN_FLAGS(0), CASTCLASS_None, TEXT("/Script/TestCall"), NO_API) \
DECLARE_SERIALIZER(AMyActor)

这个宏也很重要,包含如下内容

声明了一个友元结构 Z_Construct_UClass_AMyActor_Statics,之后程序运行时,会利用这个结构去收集类的反射信息

DECLARE_CLASS 宏,这个宏里需要注意的地方如下

  • typedef TSuperClass Super; typedef TClass ThisClass;,这就是我们经常用的 Super 定义的地方了,还有一个 ThisClass,用在之前 exec 函数定义的地方
  • inline static UClass* StaticClass() 这也是我们经常使用到的,获取一个类的反射信息对象,内部调用的是静态成员函数 GetPrivateStaticClass

TestCall_Source_TestCall_MyActor_h_12_STANDARD_CONSTRUCTORSTestCall_Source_TestCall_MyActor_h_12_ENHANCED_CONSTRUCTORS

这个宏里是用来生成构造函数了,这里是 GENERATED_BODYGENERATED_UCLASS_BODY 唯一有区别的地方

  • GENERATED_UCLASS_BODY -> TestCall_Source_TestCall_MyActor_h_12_STANDARD_CONSTRUCTORS

    这个宏里声明了一个构造函数 AMyActor(const FObjectInitializer& ObjectInitializer);,需要在 cpp 里添加实现。

    还实现了一个静态函数 static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); },这个函数里就是调用了一下 placement new,在 X.GetObj() 返回的内存地址上去构造当前对象,调用的是带 ObjectInitializer 的构造函数

  • GENERATED_BODY -> TestCall_Source_TestCall_MyActor_h_12_ENHANCED_CONSTRUCTORS

    和上面的不一样,没有声明带 ObjectInitializer 参数的构造函数,也同样实现了一个静态函数 static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass;}, 只不过 placement new 调用的是不带参数的默认构造函数

还有个不一样的地方,GENERATED_UCLASS_BODY 展开的最后是 public:,而 GENERATED_UCLASS 展开的最后是 private:,所以在编写头文件时,最好在这个两个宏后面显式加上 publicprivate,省得还得去想一下默认的是什么

总结

在上面的例子中,我们定义了一个 AMyActor,经过 UHT 处理后会得到 MyActor.generated.hMyActor.gen.cpp 两个源文件

在使用 C++ 编译器编译时,在编译的预处理阶段,对 MyActor.hMyActor.generated.h 进行宏展开,最终的结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#include "MyActor.generated.h"

class AMyActor : public AActor
{
// PRAGMA_DISABLE_DEPRECATION_WARNINGS
__pragma (warning(push))
__pragma (warning(disable:4995))
__pragma (warning(disable:4996))

// TestCall_Source_TestCall_MyActor_h_12_PRIVATE_PROPERTY_OFFSET
// empty macro

// TestCall_Source_TestCall_MyActor_h_12_RPC_WRAPPERS

virtual void MyActorBlueprintNativeEvent_Implementation();

static void execMyActorBlueprintSetter(UObject* Context, FFrame& Stack, void*const Z_Param__Result)
{
UIntProperty::TCppType Z_Param_Test = UIntProperty::GetDefaultPropertyValue();
Stack.StepCompiledIn<UIntProperty>(&Z_Param_Test);

Stack.Code += !!Stack.Code;
{
((ThisClass*)(Context))->MyActorBlueprintSetter(Z_Param_Test);
}
}

static void execMyActorBlueprintGetter(UObject* Context, FFrame& Stack, void*const Z_Param__Result)
{
Stack.Code += !!Stack.Code;

{
*(int32*)Z_Param__Result = ((ThisClass*)(Context))->MyActorBlueprintGetter();
}
}

static void execMyActorBlueprintPure(UObject* Context, FFrame& Stack, void*const Z_Param__Result)
{
Stack.Code += !!Stack.Code;

{
*(int32*)Z_Param__Result = ((ThisClass*)(Context))->MyActorBlueprintPure();
}
}

static void execMyActorBlueprintCallable(UObject* Context, FFrame& Stack, void*const Z_Param__Result)
{
Stack.Code += !!Stack.Code;

{
((ThisClass*)(Context))->MyActorBlueprintCallable();
}
}

static void execMyActorBlueprintNativeEvent(UObject* Context, FFrame& Stack, void*const Z_Param__Result)
{
Stack.Code += !!Stack.Code;

{
((ThisClass*)(Context))->MyActorBlueprintNativeEvent_Implementation();
}
}

// TestCall_Source_TestCall_MyActor_h_12_CALLBACK_WRAPPERS
// empty macro

// TestCall_Source_TestCall_MyActor_h_12_INCLASS_NO_PURE_DECLS

private:
static void StaticRegisterNativesAMyActor();
friend struct Z_Construct_UClass_AMyActor_Statics;
public:
private:
AMyActor& operator=(AMyActor&&);
AMyActor& operator=(const AMyActor&);
static UClass* GetPrivateStaticClass();
public:
/** Bitwise union of #EClassFlags pertaining to this class.*/
enum {StaticClassFlags=(0 | CLASS_Intrinsic)};

/** Typedef for the base class ({{ typedef-type }}) */
typedef AActor Super;

/** Typedef for {{ typedef-type }}. */
typedef AMyActor ThisClass;

/** Returns a UClass object representing this class at runtime */
inline static UClass* StaticClass()
{
return GetPrivateStaticClass();
}

/** Returns the package this class belongs in */
inline static const TCHAR* StaticPackage()
{
return TEXT("/Script/TestCall");
}

/** Returns the static cast flags for this class */
inline static EClassCastFlags StaticClassCastFlags()
{
return CASTCLASS_None;
}

/** For internal use only; use StaticConstructObject() to create new objects. */
inline void* operator new(const size_t InSize, EInternal InInternalOnly, UObject* InOuter = (UObject*)GetTransientPackage(), FName InName = NAME_None, EObjectFlags InSetFlags = RF_NoFlags)
{
return StaticAllocateObject(StaticClass(), InOuter, InName, InSetFlags);
}

/** For internal use only; use StaticConstructObject() to create new objects. */
inline void* operator new( const size_t InSize, EInternal* InMem )
{
return (void*)InMem;
}

friend FArchive &operator<<( FArchive& Ar, AMyActor*& Res )
{
return Ar << (UObject*&)Res;
}

// TestCall_Source_TestCall_MyActor_h_12_ENHANCED_CONSTRUCTORS
private:
/** Private move- and copy-constructors, should never be used */
AMyActor(AMyActor&&);
AMyActor(const AMyActor&);
public:
AMyActor(FVTableHelper& Helper);

static UObject* __VTableCtorCaller(FVTableHelper& Helper)
{
return nullptr;
}

static void __DefaultConstructor(const FObjectInitializer& X)
{
new((EInternal*)X.GetObj())AMyActor;
}

private:
// PRAGMA_ENABLE_DEPRECATION_WARNINGS
__pragma (warning(pop))

public:
void MyActorBlueprintImplementableEvent();

void MyActorBlueprintNativeEvent();

int32 MyActorBlueprintPure();

void MyActorBlueprintCallable();

int32 MyActorBlueprintGetter();

void MyActorBlueprintSetter(int32 Test);

int MyActorProperty;
};

其实最重要的是不管 UHT 怎样生成代码,最终都是需要用 C++ 编译器去编译,所以它生成的代码也是需要遵守 C++ 语法,在上面的例子中,其实我们有一点没有提到,那就是标记为 UFUNCTION(BlueprintImplementableEvent) 的函数我们只在 MyActor.h 中进行声明但没有实现,还有 UFUNCTION(BlueprintNativeEvent) 的函数我们在 MyActor.cpp 中实现的是 _Implementation 版本的函数,原版也没有去实现,可以肯定的是这两个函数必须要有实现,不然链接是过不了的,那么它们的实现在哪里?既然我们没有手动实现,那么肯定是 UHT 帮我们给做了,它们的原版实现就在 MyActor.gen.cpp 中,具体如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//...

static FName NAME_AMyActor_MyActorBlueprintImplementableEvent = FName(TEXT("MyActorBlueprintImplementableEvent"));
void AMyActor::MyActorBlueprintImplementableEvent()
{
ProcessEvent(FindFunctionChecked(NAME_AMyActor_MyActorBlueprintImplementableEvent),NULL);
}

static FName NAME_AMyActor_MyActorBlueprintNativeEvent = FName(TEXT("MyActorBlueprintNativeEvent"));
void AMyActor::MyActorBlueprintNativeEvent()
{
ProcessEvent(FindFunctionChecked(NAME_AMyActor_MyActorBlueprintNativeEvent),NULL);
}

// ...

所以,当我们在 C++ 中调用这两个函数时,其实就是会进到这里,然后在通过 FindFunctionChecked 去寻找蓝图中的函数,通过蓝图虚拟机进入到蓝图的函数中,用一张表来总结这些函数标记

UFUNCTION 标记 C++实现 C++ 调用 UHT 处理 蓝图实现 蓝图调用
BlueprintPure 在自己的 cpp 中进行实现 C++ 里调用直接进入到 cpp 的实现中 UHT自动生成 exec 版本 蓝图调用后进入到 exec 的版本中,然后再进入到 native 版本
BlueprintCallable 同上 同上 同上 同上 同上
BlueprintGetter 同上 同上 同上 同上 同上
BlueprintSetter 同上 同上 同上 同上 同上
BlueprintNativeEvent 自己需要在 cpp 中实现 _Implementation 版本,UHT 自动生成原版实现 先进到 .gen.cpp 的实现中,然后再进入蓝图虚拟机(如果蓝图中有实现),蓝图中没有实现的话就会调用 exec 版本,然后进到 _Implementation 实现中 UHT 自动生成原版实现到 .gen.cpp 中,还会在 .generated.h 中生成 exec 版本 可在蓝图中 重写 实现 可在蓝图中通过 Parent 调用 C++ 中的版本,这时会进到 exec 版本中,然后再进到_Implementation 的实现中
BlueprintImplementableEvent 不需要自己实现,UHT 自动生成原版实现 进到 .gen.cpp 的实现中,然后再进入蓝图虚拟机(如果蓝图中有实现) UHT 自动生成原版实现到 .gen.cpp 可在蓝图中实现 不能调用