In this lesson, you will learn how Unreal Engine’s garbage collection system manages the memory for components depending on whether they are defined in your C++ constructor or spawned during gameplay.
Constructor-Defined Components
When you define a component in your class constructor using CreateDefaultSubobject, you are telling Unreal Engine that this component is a permanent part of that Actor's template. The engine automatically handles the memory for these components. Because they are part of the "CDO" (Class Default Object), they are serialized with the Actor. You do not need to worry about manually deleting these; when the Actor is destroyed, the engine’s garbage collector identifies these components as unreachable and cleans them up for you.
// Example: Constructor-defined component
AMyActor::AMyActor()
{
MyMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyMesh"));
}
Dynamically Spawned Components
Sometimes, you need to add a component while the game is running (for example, spawning a fire effect when a barrel explodes). You typically use NewObject<T>() or AddComponentByClass() for this.
Because these are not part of the initial class template, they are considered "dynamic." To ensure the engine’s garbage collector doesn't accidentally delete your component while it's still in use, you must register it with the Actor. Using RegisterComponent() binds the component to the Actor's lifecycle. If you create a component dynamically but forget to register it or attach it to an owner, the garbage collector may see the object as having no references and clear it from memory, potentially causing a crash or a silent failure.
The Role of Garbage Collection
Unreal Engine uses a system called Automatic Garbage Collection. It periodically scans your game objects. If an object (like a component) is not "referenced" by a UPROPERTY() pointer or owned by an Actor that is still active in the world, the engine marks it for destruction. This is why always tagging your component pointers with UPROPERTY() is vital—it acts as a "flag" to the garbage collector, telling it, "Hey, I am still using this, don't delete it!"
Key Takeaway: Constructor components are managed automatically by the engine's template system, while dynamic components require you to register them with an owner and use UPROPERTY() pointers to prevent the garbage collector from reclaiming their memory prematurely.