1. 项目概述：为什么选择Unreal Engine C++？

如果你是一个对游戏开发、实时3D可视化或者交互式体验感兴趣的开发者，并且已经对C++这门“硬核”语言有了一定的了解，那么Unreal Engine（虚幻引擎，简称UE）几乎是你绕不开的一个选择。我最初接触UE时，也被它庞大的编辑器界面和复杂的蓝图系统震撼过，但当我真正开始用C++去驱动它时，才体会到那种“从底层掌控一切”的扎实感。这个项目，就是带你从零开始，搭建起UE C++开发的知识骨架，让你不仅能看懂官方文档，更能亲手写出高效、可维护的游戏逻辑。

简单来说，这个入门指南要解决的核心问题是：如何让一个熟悉标准C++语法的程序员，快速理解并运用UE那套独特的、基于反射和宏的C++扩展体系，去创建游戏对象、处理交互逻辑，并最终在虚幻编辑器中看到自己的代码生效。这不仅仅是学一门新的API，更是学习一种新的编程范式。它适合那些已经啃过C++基础（比如类、继承、多态、模板），但面对UE的UCLASS()、UPROPERTY()等宏感到一头雾水的开发者。我们将从最基础的开发环境配置讲起，一步步深入到游戏性框架的核心，避开我当年踩过的那些坑。

2. 开发环境搭建与第一个C++项目

在开始写任何一行UE C++代码之前，一个稳定、正确的开发环境是重中之重。很多新手卡在第一步，往往是因为环境没配好，导致编译失败、编辑器崩溃，信心大受打击。

2.1 工具链的精准选型与安装

UE开发对工具版本有严格的要求，不匹配的版本会导致各种诡异问题。以下是经过大量项目验证的黄金组合：

1. Unreal Engine版本：对于新手，我强烈建议从最新的长期支持（LTS）版本开始，比如UE 5.3或5.4。LTS版本经过了更长时间的稳定性和兼容性测试，社区资源（教程、问答）也更丰富，能避免你掉进最新实验性功能的坑里。直接从Epic Games Launcher安装即可。

2. 集成开发环境（IDE）：Visual Studio 2022是Windows平台上的不二之选。安装时务必勾选以下工作负载：

   • 使用C++的桌面开发：这是核心。
   • 使用C++的游戏开发：这个工作负载包含了编译UE所需的关键组件，如特定的Windows SDK版本和构建工具。这是避免“MSB3428: 未能加载Visual C++组件‘vcbuild.exe’”这类错误的根本方法。很多网络上的解决方案让你单独安装旧版Build Tools，其实都不如直接勾选这个选项来得干净彻底。

3. 必要的组件：在VS安装器的“单个组件”选项卡中，确保安装了与你UE版本对应的Windows SDK（安装器通常会为你自动选择兼容版本）。至于“Microsoft Visual C++ Redistributable”，它只是运行时库，用于运行编译好的程序，在开发时不是必须安装的组件，但你的游戏最终分发给玩家时需要包含它。

注意：网络上很多关于node-sass安装报错MSB3428的解决方案，其根源也是缺少C++构建环境。虽然问题表象相同，但UE开发的环境要求更为复杂和特定，必须通过VS的“游戏开发”工作负载来满足，而不是简单安装一个构建工具包。

安装完成后，打开Epic Games Launcher，在“库”->“引擎版本”下点击“启动”打开虚幻编辑器。不要急着创建项目，我们先创建一个最纯粹的模板来验证环境。

2.2 创建并剖析第一个C++项目

在虚幻项目浏览器中，选择“游戏”类别，然后选择“空白”模板。在项目设置下方，关键的一步来了：务必在“项目默认语言”下拉菜单中选择“C++”，而不是“蓝图”。给你的项目起个名字，比如HelloUnrealCPP，然后选择保存路径。

点击“创建”后，编辑器会自动为你生成一个解决方案文件（.sln）并用Visual Studio打开。同时，虚幻编辑器也会启动并加载这个新项目。这个过程本身就是一个成功的信号，说明你的基础环境通路是正常的。

让我们立刻看看生成了什么。回到VS，在“解决方案资源管理器”中，展开“Source”文件夹，你会看到：

• HelloUnrealCPP.Target.cs和HelloUnrealCPPEditor.Target.cs：分别定义打包（游戏）版本和编辑器版本的构建目标。
• HelloUnrealCPP目录：这是我们游戏模块的主目录。
  • HelloUnrealCPP.Build.cs：模块的构建规则文件，类似于CMakeLists.txt，用于定义该模块的依赖（如需要引入Core、Engine等UE模块）。
  • HelloUnrealCPP.cpp和HelloUnrealCPP.h：游戏模块的主入口文件，包含了一个FHelloUnrealCPPModule类，负责模块的启动和关闭。
  • HelloUnrealCPPGameModeBase.h/cpp：这就是你的第一个游戏模式（GameMode）C++类！它是整个游戏规则的导演。

现在，我们来做第一个修改，让代码“说话”。在HelloUnrealCPPGameModeBase.cpp的BeginPlay函数里（如果没有，就在类构造函数里），添加一行日志输出：

// HelloUnrealCPPGameModeBase.cpp #include "HelloUnrealCPPGameModeBase.h" #include "Engine/Engine.h" // 需要包含这个头文件以使用GEngine void AHelloUnrealCPPGameModeBase::BeginPlay() { Super::BeginPlay(); // 务必先调用父类方法 // 在屏幕和输出日志中显示一条消息 if (GEngine) { GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("Hello, Unreal C++!")); } UE_LOG(LogTemp, Log, TEXT("Hello, Unreal C++ from Log!")); }

保存所有文件，回到虚幻编辑器。编辑器会检测到代码变化，右下角出现“编译”按钮，点击它。如果一切顺利，编译完成后，点击编辑器工具栏上的“播放”按钮，在游戏视窗中，你应该能看到绿色的“Hello, Unreal C++!”字样显示5秒钟。同时，在“输出日志”窗口（Window -> Developer Tools -> Output Log）里，也能看到相应的日志条目。

实操心得：第一次编译可能会比较慢，因为要构建整个引擎的依赖。编译成功后，后续对单个文件的修改编译会快很多。如果编译失败，请首先检查VS的输出窗口，错误信息通常非常具体，例如找不到头文件、链接错误等，根据错误信息去搜索是最高效的排查方式。

3. Unreal C++核心语法与反射系统揭秘

如果你写的标准C++类，在UE编辑器里无法被看到、无法设置属性、无法被蓝图继承，那它就只是一个“哑巴”类。UE的强大之处在于其反射系统，它允许在运行时查询和操作类、属性、函数的信息。而我们与反射系统交互的桥梁，就是一系列以U或A开头的宏。

3.1 UCLASS, UPROPERTY, UFUNCTION：与编辑器对话的宏

这是UE C++最标志性的语法，也是新手最需要适应的地方。

1. UCLASS()：用于声明一个可以被UE识别和管理的类。所有需要出现在内容浏览器、能被蓝图继承或被其他UE系统引用的类，都必须用它来标记。

   // MyActor.h #pragma once #include "GameFramework/Actor.h" #include "MyActor.generated.h" // 必须包含这个生成的头文件 UCLASS() // 注意，没有分号 class AMyActor : public AActor // UE中，继承自AActor的类通常以A开头 { GENERATED_BODY() // 必须的宏，用于生成反射代码 public: // ... 构造函数、函数声明 };

   这个UCLASS()宏会在编译时，由Unreal Header Tool（UHT）解析，并生成额外的代码（在MyActor.generated.h中），这些代码实现了反射所需的信息。

2. UPROPERTY()：用于声明一个类的成员变量为“属性”。只有被它标记的变量，才能：

   • 在编辑器细节面板中显示和编辑。
   • 被蓝图读写。
   • 被网络复制（用于多人游戏）。
   • 参与垃圾回收（对于UObject派生类的指针）。

   UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="My Properties") float Health; UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="My Properties") FString CharacterName; UPROPERTY(EditDefaultsOnly, Category="Weapon") TSubclassOf<class AWeapon> WeaponClass;

   参数解析：

   • EditAnywhere: 可在编辑器的属性面板（默认值和实例）中编辑。
   • VisibleAnywhere: 在属性面板中可见但不可编辑。
   • BlueprintReadWrite/ReadOnly: 允许/禁止蓝图读写。
   • Category: 在属性面板中的分组，保持整洁。

3. UFUNCTION()：用于声明一个成员函数，使其可以被蓝图调用、绑定为事件、或被网络远程调用。

   UFUNCTION(BlueprintCallable, Category="My Functions") void DealDamage(float DamageAmount); UFUNCTION(BlueprintImplementableEvent, Category="My Events") // 这是一个蓝图可实现事件 void OnHealthDepleted(); UFUNCTION(BlueprintNativeEvent, Category="My Events") // 这是一个有C++默认实现的蓝图可覆盖事件 void OnItemPickedUp(); void OnItemPickedUp_Implementation(); // 默认实现的后缀是_Implementation

为什么需要这些宏？标准C++没有运行时类型信息（RTTI）能强大到支持如此丰富的编辑器集成和跨语言（C++/蓝图）互操作。UE通过这套宏+UHT的预编译流程，在C++语言之上构建了一个强大的元数据层，这是它生产力工具链的基石。

3.2 Unreal 智能指针与容器：安全的内存管理

UE有自己的内存管理哲学，尤其是对于继承自UObject的对象。你绝对不能使用C++标准的new/delete或std::shared_ptr来创建/销毁UObject。

1. NewObject/CreateDefaultSubobject：创建UObject的正确方式。

   // 在运行时动态创建一个UObject UMyObject* MyObj = NewObject<UMyObject>(this); // ‘this‘通常作为Outer（外部对象） // 在Actor构造函数中创建组件（子对象） AMyActor::AMyActor() { PrimaryActorTick.bCanEverTick = true; // 创建一个场景组件作为根组件 SceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneComp")); RootComponent = SceneComponent; // 创建一个静态网格体组件 MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComp")); MeshComponent->SetupAttachment(RootComponent); }

   CreateDefaultSubobject专用于在构造函数中创建组件，这些组件会成为Actor默认对象的一部分，并被编辑器序列化。

2. TSharedPtr,TWeakPtr,TUniquePtr：对于非UObject对象（即普通的C++类），UE提供了自己的一套智能指针，功能类似标准库，但与UE的内存分配器集成更好。

   TSharedPtr<FMyData> SharedData = MakeShared<FMyData>(); TWeakPtr<FMyData> WeakData = SharedData; // 弱引用，不增加引用计数 TUniquePtr<FMyData> UniqueData = MakeUnique<FMyData>(); // 独占所有权

3. TArray,TMap,TSet：UE提供的容器类，比STL容器更安全（有更好的边界检查），与UE的其他系统（如网络序列化、蓝图）集成更佳，并且性能经过高度优化。

   UPROPERTY() TArray<AActor*> OverlappingActors; // 最常用的动态数组 TMap<FString, int32> PlayerScores; // 字典 if (int32* Score = PlayerScores.Find(PlayerName)) { // 找到分数 } TSet<UPrimitiveComponent*> ProcessedComponents; // 集合，用于快速查找和去重

注意事项：TArray的迭代器在元素被添加或删除时可能会失效，在循环中修改数组结构要格外小心。通常建议先收集需要处理的信息，再统一修改。

4. 游戏性框架核心类解析与实践

理解了基础语法，我们就要进入UE世界的核心——游戏性框架（Gameplay Framework）。这是一套定义游戏运行逻辑的类层次结构，理解它们的关系至关重要。

4.1 Actor与Component：组合优于继承

AActor是所有可以放入关卡的对象的基类。但UE不鼓励通过深度继承树来构建复杂的Actor，而是推崇使用组件（Component）模式。

• AActor：像一个空的容器或挂架。它本身可以拥有位置、旋转、缩放（通过RootComponent），可以Tick（每帧更新），可以绑定事件。但它的具体能力（渲染、物理、声音）都来自于它拥有的组件。
• UActorComponent：可复用的功能模块。一个UStaticMeshComponent负责渲染网格，一个UAudioComponent负责播放声音，一个UBoxComponent负责碰撞检测。你可以像搭积木一样，将不同的组件添加到一个Actor上，组合出复杂的行为。

最佳实践：当你想要为一个Actor添加新功能时，首先考虑是否应该创建一个新的Component，而不是继承一个新的Actor子类。这样功能更解耦，复用性更高。例如，一个“可被破坏的”功能，可以做成一个UBreakableComponent，然后任何需要此功能的Actor（门、箱子、墙壁）都可以添加它。

让我们创建一个带自定义组件的Actor：

1. 创建自定义Component：在编辑器中或通过右键源文件目录，新建一个C++类，选择“ActorComponent”作为父类，命名为URotatingComponent。
2. 在RotatingComponent.h中：

   #pragma once #include "Components/ActorComponent.h" #include "RotatingComponent.generated.h" UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent)) class HELLOUNREALCPP_API URotatingComponent : public UActorComponent { GENERATED_BODY() public: URotatingComponent(); virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override; UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Rotation") FRotator RotationRate; // 每秒钟旋转的角度 protected: virtual void BeginPlay() override; };

3. 在RotatingComponent.cpp中：

   #include "RotatingComponent.h" URotatingComponent::URotatingComponent() { PrimaryComponentTick.bCanEverTick = true; // 启用每帧Tick RotationRate = FRotator(0, 90, 0); // 默认每秒绕Y轴旋转90度 } void URotatingComponent::BeginPlay() { Super::BeginPlay(); } void URotatingComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) { Super::TickComponent(DeltaTime, TickType, ThisTickFunction); AActor* Owner = GetOwner(); if (Owner) { FRotator NewRotation = Owner->GetActorRotation() + (RotationRate * DeltaTime); Owner->SetActorRotation(NewRotation); } }

4. 创建使用该Component的Actor：同样新建一个继承自Actor的C++类，命名为ARotatingCube。在其构造函数中，添加我们的旋转组件。

   // RotatingCube.h UCLASS() class HELLOUNREALCPP_API ARotatingCube : public AActor { GENERATED_BODY() public: ARotatingCube(); UPROPERTY(VisibleAnywhere, BlueprintReadOnly) class UStaticMeshComponent* CubeMesh; UPROPERTY(VisibleAnywhere, BlueprintReadOnly) class URotatingComponent* Rotator; }; // RotatingCube.cpp #include "RotatingCube.h" #include "Components/StaticMeshComponent.h" #include "RotatingComponent.h" // 包含自定义组件头文件 ARotatingCube::ARotatingCube() { PrimaryActorTick.bCanEverTick = false; // Actor本身不需要Tick CubeMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("CubeMesh")); RootComponent = CubeMesh; // 设为根组件 // 可以在这里设置一个默认的静态网格体（需要后续在编辑器或代码中指定） Rotator = CreateDefaultSubobject<URotatingComponent>(TEXT("Rotator")); // Rotator会自动附加到Owner（即this Actor）上 }

编译后，在编辑器内容浏览器中右键创建“蓝图类”，选择ARotatingCube作为父类。打开这个蓝图，在细节面板中，你可以看到CubeMesh和Rotator组件。你可以为CubeMesh指定一个形状，并在Rotator上调整Rotation Rate。将这个蓝图拖入关卡，运行游戏，你就会看到一个自动旋转的物体。这个例子完美展示了Component的复用性：你可以把这个Rotator组件加到任何Actor上，让它旋转起来。

4.2 Pawn, Controller与GameMode：掌控游戏流程

这是UE中控制游戏单元和规则的核心三角。

• APawn：代表游戏世界中一个可被“控制”的实体。它不一定非要是玩家角色，也可以是AI控制的单位。Pawn通常包含移动组件（MovementComponent）和Controller的引用。
• AController：负责控制一个Pawn。PlayerController处理来自玩家的输入，AIController则执行AI逻辑。控制器与Pawn是分离的，这意味着你可以轻松地在不同的Pawn之间切换控制权（比如角色死亡后切换到一个观察者相机）。
• AGameModeBase：定义游戏规则。它负责：
  • 游戏何时开始/结束。
  • 默认的Pawn和PlayerController类是什么。
  • 如何生成玩家（通过PlayerStart）。
  • 分数、回合等游戏状态的管理。
  • 它只在服务器上存在（在多人游戏中）。

一个简单的流程：游戏开始时，GameMode根据规则生成一个PlayerController。PlayerController生成或获取一个Pawn并与之绑定。玩家的输入被PlayerController接收，并转化为对Pawn的操作指令（如移动、跳跃）。GameMode监控游戏状态（如所有敌人都被击败），然后宣布游戏胜利。

5. 输入绑定、碰撞与简单交互实现

现在，让我们把旋转的方块变成可以由玩家控制移动，并与其他物体发生交互的“角色”。

5.1 绑定玩家输入

首先，我们需要设置输入映射。在编辑器中选择“编辑”->“项目设置”->“引擎”->“输入”。在“绑定”区域，添加两个“操作映射”（用于离散动作，如跳跃）和两个“轴映射”（用于连续值，如移动）。

• 操作映射：
  • Jump：空格键
  • Interact：E键
• 轴映射：
  • MoveForward：W键（Scale 1.0），S键（Scale -1.0）
  • MoveRight：A键（Scale -1.0），D键（Scale 1.0）

接下来，修改我们的ARotatingCube，让它继承自APawn（或ACharacter，后者已内置了复杂的移动组件），并处理输入。

1. 修改父类：将ARotatingCube的父类改为APawn（需要修改头文件和构造函数初始化列表）。
2. 添加输入处理函数：

   // RotatingCube.h public: ... virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override; private: void MoveForward(float Value); void MoveRight(float Value); void Jump(); void Interact();

3. 实现输入绑定与处理：

   // RotatingCube.cpp #include "GameFramework/PawnMovementComponent.h" // 为了使用简单的移动组件 void ARotatingCube::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) { Super::SetupPlayerInputComponent(PlayerInputComponent); // 绑定轴映射 PlayerInputComponent->BindAxis("MoveForward", this, &ARotatingCube::MoveForward); PlayerInputComponent->BindAxis("MoveRight", this, &ARotatingCube::MoveRight); // 绑定操作映射 PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ARotatingCube::Jump); PlayerInputComponent->BindAction("Interact", IE_Pressed, this, &ARotatingCube::Interact); } void ARotatingCube::MoveForward(float Value) { if (Value != 0.0f) { // 获取控制器的旋转，但忽略俯仰和翻滚，只使用偏航（Yaw）来获得前进方向 FRotator ControlRotation = GetControlRotation(); ControlRotation.Pitch = 0.0f; ControlRotation.Roll = 0.0f; FVector Direction = FRotationMatrix(ControlRotation).GetUnitAxis(EAxis::X); AddMovementInput(Direction, Value); } } void ARotatingCube::MoveRight(float Value) { if (Value != 0.0f) { FRotator ControlRotation = GetControlRotation(); ControlRotation.Pitch = 0.0f; ControlRotation.Roll = 0.0f; FVector Direction = FRotationMatrix(ControlRotation).GetUnitAxis(EAxis::Y); AddMovementInput(Direction, Value); } } void ARotatingCube::Jump() { // 简单实现一个向上的冲量 UPrimitiveComponent* RootPrimitive = Cast<UPrimitiveComponent>(RootComponent); if (RootPrimitive) { RootPrimitive->AddImpulse(FVector(0, 0, 50000), NAME_None, true); } } void ARotatingCube::Interact() { UE_LOG(LogTemp, Warning, TEXT("Interact key pressed!")); // 这里可以触发射线检测、与重叠物体交互等逻辑 }

4. 配置GameMode：在关卡中或项目设置里，将游戏的默认Pawn类设置为我们的ARotatingCube蓝图。运行游戏，你就可以用WASD移动方块，按空格跳跃，按E键会在输出日志看到消息。

5.2 碰撞检测与交互

让我们的方块能够感知周围环境。我们使用UPrimitiveComponent（如UStaticMeshComponent）自带的碰撞系统。

1. 设置碰撞预设：在编辑器中打开RotatingCube的蓝图，选中CubeMesh组件，在细节面板的“碰撞”部分，设置“碰撞预设”。例如，设置为“Pawn”，这样它就能与其他碰撞体发生碰撞和重叠事件。
2. 在C++中绑定重叠事件：在ARotatingCube的构造函数或BeginPlay中，为网格体组件绑定重叠事件委托。

   // RotatingCube.cpp - 构造函数中 ARotatingCube::ARotatingCube() { ... if (CubeMesh) { CubeMesh->SetCollisionProfileName(TEXT("Pawn")); // 代码中设置碰撞预设 CubeMesh->OnComponentBeginOverlap.AddDynamic(this, &ARotatingCube::OnOverlapBegin); CubeMesh->OnComponentEndOverlap.AddDynamic(this, &ARotatingCube::OnOverlapEnd); } } // 声明委托函数 UFUNCTION() void OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult); UFUNCTION() void OnOverlapEnd(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);

3. 实现重叠事件逻辑：

   void ARotatingCube::OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult) { if (OtherActor && (OtherActor != this)) { FString OtherName = OtherActor->GetName(); UE_LOG(LogTemp, Log, TEXT("%s began overlapping with %s"), *GetName(), *OtherName); // 例如，可以在这里检查OtherActor是否是某种类型的物品，然后触发拾取逻辑 } } void ARotatingCube::OnOverlapEnd(...) { // 类似处理结束重叠 }

现在，当你的方块在游戏中移动到另一个带有碰撞的Actor上时，输出日志就会记录重叠事件。你可以在此基础上扩展出拾取物品、触发机关、进入区域等丰富的游戏逻辑。

6. 调试、性能分析与常见问题排查实录

即使是最有经验的开发者，大部分时间也是在调试和解决问题。掌握UE C++的调试技巧，能极大提升开发效率。

6.1 高效的调试手段

1. UE_LOG：你的第一道防线：这是最常用、最灵活的调试工具。除了LogTemp，你可以定义自己的日志类别，以便在输出日志中过滤。

   // 在头文件中定义自己的日志类别 DECLARE_LOG_CATEGORY_EXTERN(MyGameLog, Log, All); // 在cpp文件中实现 DEFINE_LOG_CATEGORY(MyGameLog); // 使用 UE_LOG(MyGameLog, Warning, TEXT("Player %s health is now %f"), *PlayerName, Health);

   在编辑器输出日志窗口，你可以通过类别过滤，只看自己关心的日志。

2. GEngine->AddOnScreenDebugMessage：实时视觉反馈：适合显示需要实时监控的变量值，如速度、状态等。注意控制消息的生存期和键值（Key），避免屏幕信息堆积。

   // 键值-1表示每次调用都创建新消息，键值非负则更新同键值消息 GEngine->AddOnScreenDebugMessage(-1, 0.1f, FColor::Yellow, FString::Printf(TEXT("Speed: %.2f"), CurrentSpeed));

3. 断点与Visual Studio调试：这是解决复杂逻辑问题的终极武器。确保你的VS解决方案配置是“DebugGame Editor”或“Development Editor”，然后在代码行号旁点击设置断点。从VS启动调试（F5），或者附加到已运行的编辑器进程（调试 -> 附加到进程 -> 找到UnrealEditor.exe）。在断点处，你可以查看调用堆栈、监视变量、修改变量值，甚至执行表达式。

4. 蓝图调试器：即使你在写C++，如果你的类暴露了蓝图可调用的函数或事件，你仍然可以在蓝图中设置断点，单步执行蓝图节点，这对于排查C++与蓝图交互的问题非常有用。

6.2 常见编译与运行时问题排查

以下是我在项目中反复遇到的典型问题及其解决方案：

性能分析小技巧：使用UE内置的“Stat”命令。在游戏运行时按“~”打开控制台，输入stat unit查看帧时间和线程耗时，stat game查看游戏线程信息，stat rhi查看渲染开销。这对于定位性能瓶颈至关重要。

从环境搭建到核心语法，从框架理解到交互实现，最后到问题排查，这条路径覆盖了UE C++入门最核心的实战环节。记住，UE开发是一个“边做边学”的过程，不要试图一次性记住所有API。最好的学习方式是定一个小目标（比如“做一个可以移动、跳跃、拾取物品的角色”），然后遇到问题就去查文档、搜社区、看引擎源码。当你亲手解决掉一个又一个的编译错误和逻辑Bug，看着自己用代码创造的世界在屏幕上活起来时，那种成就感是无与伦比的。