🗑️ Lesson 2.5: Memory & Garbage Collection

Two Memory Worlds

The single most important distinction: Unreal has two kinds of objects with two memory strategies.

The UObject Lifecycle

A UObject moves through well-defined phases. For actors specifically, you'll hook into several of these in Module 3:

Reachability & UPROPERTY

The GC uses reachability: starting from a set of "root" objects, it follows every UPROPERTY pointer. Any UObject it can reach is kept; anything it can't reach is destroyed. This is the whole game.

UCLASS()
class MYPROJECT_API AEnemy : public AActor
{
    GENERATED_BODY()

    // ✅ Reachable: the GC follows this and keeps the loadout alive.
    UPROPERTY()
    UWeaponData* Loadout;

    // ⚠️ Invisible to GC: the pointed-to object can be destroyed while we
    // still hold this address — a dangling pointer waiting to crash.
    UWeaponData* CachedLoadout;
};

To validate a pointer before use, Unreal gives you IsValid(), which is safer than a bare null check because it also catches objects pending destruction:

if (IsValid(Target))
{
    Target->TakeDamage(10.0f);   // safe: not null AND not pending kill
}

TObjectPtr & TWeakObjectPtr

Modern Unreal has two wrapper types for UObject references you should know:

TObjectPtr<T> — the modern strong reference

In UE5, Epic recommends declaring UObject pointer members as TObjectPtr<T> instead of raw T*. It behaves like a pointer but gives the engine extra tooling (access tracking, lazy loading support). It's still a UPROPERTY and still keeps the object alive.

// Modern UE5 style for a strong-owned UObject member:
UPROPERTY(VisibleAnywhere)
TObjectPtr<UStaticMeshComponent> Mesh;

// You use it just like a raw pointer:
if (Mesh) { Mesh->SetVisibility(true); }

TWeakObjectPtr<T> — a non-owning reference

Use this when you want to refer to a UObject without keeping it alive, and you're fine with it becoming invalid when the object is destroyed. It never causes a dangling-pointer crash because you must check it before use.

// "I want to remember my last target, but not keep it alive."
UPROPERTY()
TWeakObjectPtr<AActor> LastTarget;

// Access pattern — always resolve and check:
if (AActor* Target = LastTarget.Get())
{
    // Target is valid right now.
}

Smart Pointers for Non-UObjects

The GC only manages UObjects. For plain C++ classes and structs (not UCLASS), Unreal provides its own smart pointer family — the equivalent of the standard library's, but Unreal-flavored:

// A plain (non-UObject) helper class:
class FDamageCalculator { /* ... */ };

// Single owner — freed automatically when the owner is destroyed:
TUniquePtr<FDamageCalculator> Calculator = MakeUnique<FDamageCalculator>();

// Shared ownership when several systems need to hold it:
TSharedPtr<FDamageCalculator> Shared = MakeShared<FDamageCalculator>();
TWeakPtr<FDamageCalculator> Observer = Shared;   // watches without owning

Hands-on Exercise & Quiz

UCLASS()
class MYPROJECT_API ATurret : public AActor
{
    GENERATED_BODY()

    UWeaponData* Weapon;                 // (a)
    TSharedPtr<UWeaponData> SharedWeapon; // (b)
    AActor* CurrentTarget;               // (c) we observe it; it may die

    void Cleanup()
    {
        delete Weapon;                    // (d)
    }
};

Summary

📚 Additional Resources

• Unreal Object Handling & Garbage Collection (Epic)
• Smart Pointers in Unreal Engine (Epic)

🚀 What's Next?

The last foundation piece is the one you'll use every single day: logging, assertions, and debugging — how to see what your code is doing and catch mistakes early with UE_LOG, check, and ensure.