Highlights
- Game Unreal Engine pairs high-performance C++ with Blueprints for a powerful, flexible dev workflow.
- Macros like UPROPERTY and UFUNCTION bridge code to the editor while the Garbage Collector automates memory.
- Mastering Actors, Components, and specifiers ensures your game is both performant and easily customizable by designers.
Transitioning to Unreal Engine can feel akin to stepping into the cockpit of a spaceship. For developers arriving from traditional software development or other game engines, the realization quickly dawns that Unreal does not merely use C++; the engine transforms the language.
Unreal Engine uses a dual-language approach: a foundational, high-performance C++ backend paired with the highly visual, node-based Blueprint system. The golden rule dictates that heavy math, complex AI, and foundational systems belong in C++, while visual tweaks, asset assignments, and rapid iteration belong in Blueprints.
The following sections break down the foundational concepts, language quirks, and essential patterns necessary for mastering C++ in Unreal Engine.
The Language Basics: Unreal's Spin on C++
Standard C++ is great, but it’s built for everything from toasters to supercomputers. Unreal needs extreme precision for things like network replication and massive open worlds, so it brings its own specific data types.
Sized Types and Big Worlds
Unreal recommends explicitly sized types for serialized or replicated data to maintain consistency across PCs, consoles, and mobile devices.
- Use int32 for standard whole numbers (or uint32 if it's unsigned).
- For 3D math, Unreal Engine 5 uses double (eight bytes) for floating-point calculations. This allows for incredibly massive open worlds without your player character jittering when they walk millions of units away from the map's center.
The Three Flavors of Strings
Unreal throws out standard C++ std::string in favor of three specialized string types. Using the right one is critical for game performance:
- FString: A general-purpose, modifiable string. This string type can be chopped, changed, and utilized heavily for debugging.
- FName: A lightweight, immutable string used for lightning-fast dictionary lookups (such as finding a specific bone in a skeleton).
- FText: The player-facing string. Any text appearing on the UI must be FText, as the type includes built-in translation and localization support
Pointers and References
Traditionally in C++, raw pointers (T*) were ubiquitous. In Unreal Engine 5, saving a persistent object reference in a header file is recommended using TObjectPtr<T>. In a shipped game, this pointer type behaves exactly like a raw pointer (with zero performance hit), but in the editor, utilizing TObjectPtr<T> tracks asset loading and memory management.
When passing large chunks of data (like a 3D Transform) into a function, passing by reference (e.g., const FTransform&) prevents memory waste caused by copying data. If the function is meant to modify that data, the Unreal coding standard requires prefixing the variable name with "Out" (like OutHitResult) to indicate that the data will undergo changes.
Classes and Inheritance
Unreal is strictly object-oriented, with almost every foundational class tracing its lineage back to a single base ancestor: UObject.
Crucially, multiple inheritance is strictly forbidden for UObject-derived classes. Creating a hybrid class that simultaneously inherits from a custom AVehicle and a custom AWeapon is not possible. Sharing uniform behaviors across entirely unrelated branches of a project requires the implementation of Interfaces.
Pexels
The Magic Macros: UPROPERTY, UFUNCTION, and UCLASS
Standard C++ is statically typed; once compiled, the code discards variable names and class structures. However, the Unreal Editor requires knowledge of the code to enable visual tweaking in Blueprints.
This introduces the Unreal Property System (Reflection). Tagging C++ code with special, all-caps macros signals the Unreal Header Tool (UHT) to generate boilerplate code linking the C++ layer to the editor.
- UCLASS(): Placed above a class definition to expose it to the engine.
- UPROPERTY(): Placed above variables. This lets you dictate how Blueprints and the editor can see and edit the variable.
- UFUNCTION(): Placed above functions. It allows Blueprints to call C++ logic, or even for C++ to ask the server to run a command over the network.
The Garbage Collector: Keeping Memory Clean
In standard C++, creating memory and failing to delete that memory results in a leak. Unreal prevents this issue through an automated Garbage Collector (GC).
The GC periodically sweeps through the game's memory. If it finds a UObject that isn't actively being used or referenced, it destroys it to free up RAM.
The Catch: The Garbage Collector only tracks pointers marked with the UPROPERTY() macro. Creating an object and storing the reference in a standard raw pointer without a UPROPERTY() tag leads the engine to assume the object is abandoned, resulting in deletion. Subsequent attempts by the code to access the missing object will cause a crash (a fatal dangling pointer). Tracked object pointers must always be tagged.
The Building Blocks: Actors and Components
If UObject is the DNA, the AActor is the body. An Actor is anything that can be placed into a level. However, an Actor by itself is just an empty management shell. It gets its physical form and behaviors from Components.
- Actor Components (UActorComponent): The brains. These hold abstract logic, like a health manager or an inventory system. They have no physical location in the world.
- Scene Components (USceneComponent): The brawn. These inherit from Actor Components but add a physical location in the 3D world (a transform). Static meshes, cameras, and collision spheres are all Scene Components.
Pexels
Bridging the Gap: C++ and Blueprints Working Together
The magic of Unreal is letting programmers write heavy logic in C++, while giving designers the keys to tweak the fun stuff in Blueprints. This sharing is controlled using property specifiers.
When to Expose Variables
When creating a variable in C++, the level of interaction allowed in the editor must be determined:
- VisibleAnywhere: Great for components. The designer can see them, but can't accidentally overwrite the core pointer.
- EditAnywhere: The designer can change the value on the base blueprint and on any specific instance placed in the world. (Use carefully, as it can cause messy data fragmentation!).
- EditDefaultsOnly: The gold standard for gameplay variables (like Max Health or Weapon Damage). Designers can only tweak it on the master Blueprint, meaning balancing changes instantly apply to every instance across the entire game.
Sharing Functions
Using BlueprintNativeEvent creates a hybrid function. The C++ code provides the core mathematics, but visual effects (like spawning a particle explosion) can be overridden or extended directly in the Blueprint.
Putting It Together: A Worked Example
Let's build a functional Interactable Actor in C++ that exposes variables cleanly to designers and allows them to override behavior using Blueprints.
Create a new C++ class deriving from AActor. We will establish a visible mesh component, adjustable interaction variables, and a native event function.
C++
// InteractableActor.h
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "InteractableActor.generated.h"
UCLASS(Blueprintable, Category = "Interaction")
class MYGAME_API AInteractableActor : public AActor
{
GENERATED_BODY()
public:
AInteractableActor();
protected:
virtual void BeginPlay() override;
public:
// Protected sub-component exposed safely to the editor layout
UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Components")
TObjectPtr<UStaticMeshComponent> MeshComponent;
// Adjustable gameplay values kept strictly within the default archetypes
UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Interaction")
float InteractionRange = 200.0f;
UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Interaction")
FText InteractionPrompt = FText::FromString(TEXT("Press E to Interact"));
// Function called by player inputs to kick off logic
UFUNCTION(BlueprintCallable, Category = "Interaction")
void Interact();
// Hybrid function: Has a C++ fallback implementation but can be overridden in Blueprints
UFUNCTION(BlueprintNativeEvent, Category = "Interaction")
void OnInteracted();
};
// InteractableActor.cpp
#include "InteractableActor.h"
AInteractableActor::AInteractableActor()
{
PrimaryActorTick.bCanEverTick = false;
MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComponent"));
RootComponent = MeshComponent;
}
void AInteractableActor::BeginPlay()
{
Super::BeginPlay();
}
void AInteractableActor::Interact()
{
OnInteracted();
}
void AInteractableActor::OnInteracted_Implementation()
{
GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Green,
TEXT("Interacted with!") + InteractionPrompt.ToString());
}
Google DeepMind
The Blueprint Finish
Now, your game designers can interact with this class directly inside the Unreal Editor:
- Right-click in the Content Browser to bring up the context menu. Select Blueprint Class under the Create Basic Asset section. Choose a Parent Class for your Blueprint.
- Inside the Blueprint Editor, assign a 3D treasure chest model to the MeshComponent in the Details panel.
- Tweak the InteractionRange and custom InteractionPrompt text inside the Details panel without modifying a single line of code.
- Open the Blueprint Event Graph, override the Event On Interacted node, and connect an animation playback node, item generation node, or a sound effect.
By utilizing Add Call to Parent Function on the overridden Blueprint node, the pristine, underlying C++ logic runs right alongside their design additions.
Mastering C++ in Unreal Engine is all about respecting the architecture. By using specific types, tagging memory properly with macros, and setting up smart boundaries between C++ code and Blueprint designers, you’ll build games that are highly performant, bug-free, and incredibly easy for your whole team to iterate on.
