UObject & Reflection

UObject is the base class for nearly every managed Unreal type. It enables reflection, serialization, garbage collection, networking, and Blueprint exposure. Classes outside the UObject hierarchy get none of these engine services.

UPROPERTY() exposes a member variable to the reflection system — enabling editor editing, serialization, replication, and GC tracking. UFUNCTION() does the same for a method, enabling Blueprint calls, RPCs, and delegate binding.

BlueprintCallable functions have an execution pin and may change state. BlueprintPure functions have no exec pin, are assumed side-effect-free, and re-run every time their output is read. Use Pure only for cheap, deterministic getters.

AActor and UActorComponent both derive from UObject. An AActor can be placed in a level and owns components. UActorComponent is attached behaviour; USceneComponent is a UActorComponent that adds a transform, so it has a world position.

EditAnywhere lets a property be changed in the editor Details panel; VisibleAnywhere shows it read-only there. BlueprintReadWrite lets Blueprint graphs get and set it; BlueprintReadOnly allows only reading. Edit/Visible target the editor, Blueprint* target graphs.

The constructor sets defaults and creates components — it runs with no world. PostInitializeComponents runs once components are registered, before play. BeginPlay runs when gameplay starts. Tick runs every frame. Each marks a later, more complete stage.

The CDO is a single template instance the engine creates per UClass. It holds the default values for every property. New instances are initialized by copying the CDO, and the editor edits the CDO itself when you change a class's defaults.

Without UPROPERTY() the garbage collector cannot see the reference, so it does not keep the object alive and does not null the pointer when the object is collected. The result is a dangling pointer that crashes later — a delayed, hard-to-trace bug.

UCLASS() marks a class so the Unreal Header Tool generates reflection metadata for it. GENERATED_BODY() is a placeholder inside the class body that UHT expands into required boilerplate — type info, casting helpers, and accessors. Both are mandatory.

UObject* and TObjectPtr are strong references that keep an object alive. TWeakObjectPtr is non-owning and goes null on collection. TSoftObjectPtr is a lazy path-based reference to a possibly unloaded asset. TSubclassOf is a type-safe class reference, not an instance.

Mark it UPROPERTY(EditAnywhere, meta = (ClampMin = "0", ClampMax = "10")). ClampMin/ClampMax hard-limit typed values; UIMin/UIMax bound the drag slider. The clamp is enforced by the editor, so code can still set out-of-range values.

BlueprintImplementableEvent has no C++ body — it is implemented entirely in Blueprint. BlueprintNativeEvent has a C++ default implementation (an _Implementation function) that a Blueprint may override. Use Native when you need a fallback in code.

The constructor also runs on the CDO at editor and load time, when there is no world, no other actors, and no gameplay context. Code that spawns actors, reads the world, or assumes runtime state will misbehave or crash. Put such logic in BeginPlay.

C++ RTTI only provides type identity and dynamic_cast; it cannot enumerate members or read metadata. Unreal's reflection exposes properties and functions by name, powering the editor, Blueprints, networking, and serialization — capabilities standard C++ has no equivalent for.

Use TSoftObjectPtr when you want to reference an asset without forcing it into memory. A hard reference loads the whole dependency chain with the owner. A soft reference defers loading, cutting memory footprint and load times for optional or large assets.

Before the C++ compiler runs, UHT parses headers containing UCLASS/UPROPERTY/UFUNCTION macros and generates .generated.h and .gen.cpp files holding the reflection tables and boilerplate. The normal compiler then builds your code together with the generated code.

Each placed instance stores only a delta against the CDO — properties it explicitly overrode. Editing the Blueprint default changes the CDO, and that new value propagates only to properties an instance has not overridden. Once a designer touched a property on the instance, it has its own delta and ignores the CDO. Reset-to-default clears the delta.

A UPROPERTY TObjectPtr is a strong reference: the GC traverses it every reachability pass and it keeps the target alive, so millions of them lengthen the mark phase. TWeakObjectPtr is not traversed and does not keep anything alive — cheap to scan, resolved by a serial-number check. TSoftObjectPtr is just a path, never traced, and may not be loaded at all.

Live Coding patches machine code in place but cannot rebuild reflection: a new or renamed UPROPERTY, a changed UCLASS layout, or an altered vtable need a fresh .generated.h from UHT, which only a full editor restart applies. Patching anyway leaves stale vtables, properties the GC and serializer cannot see, and often a GC assert. Header and CDO changes always require a restart.

Saved assets store property values keyed by reflected name, so a plain rename silently drops the old value. Add a CoreRedirects entry in DefaultEngine.ini mapping old name to new so the loader rebinds it. A type change is not redirectable: implement Serialize or PostLoad with a custom version (FCustomVersion) to read the old layout and convert it.