Pointers & References in Unreal C++: A Beginner’s Guide to Memory Management
Learn Unreal Engine C++ pointers & references with practical examples! Understand memory management, avoid crashes, and master `UPROPERTY()`, `TSharedPtr`, and more in this beginner-friendly guide.
1. What Are References in Unreal C++?
A reference acts like a guaranteed alias to an existing variable. Here’s a practical example:
void HealPlayer(APlayerCharacter& Player, float Amount) {
Player.Health += Amount; // Directly modifies the original Player!
}Why use references?
- No null checks required.
- Ideal for performance-critical functions.
2. Raw Pointers in Unreal C++
Pointers store memory addresses and can be risky if mishandled. Always use UPROPERTY() for Unreal-managed objects:
UPROPERTY(EditAnywhere)
AActor* MyActor; // Safe with UPROPERTY()
void UseActor() {
if (MyActor != nullptr) {
MyActor->Destroy();
}
}Common Pitfalls:
🚨 Avoid dangling pointers: Forgetting UPROPERTY() can lead to crashes.
3. Smart Pointers: TSharedPtr, TWeakPtr, TUniquePtr
Unreal’s smart pointers automate memory management:
a) TSharedPtr (Shared Ownership)
TSharedPtr<FGameConfig> Config = MakeShared<FGameConfig>();b) TWeakPtr (Non-Owning Reference)
TWeakPtr<AEnemy> WeakEnemy = SharedEnemy;
if (TSharedPtr<AEnemy> Enemy = WeakEnemy.Pin()) {
// Enemy is still valid!
}c) TUniquePtr (Exclusive Ownership)
TUniquePtr<FBulletPool> BulletPool = MakeUnique<FBulletPool>();4. When to Use Each?
| Scenario | Best Choice |
|---|---|
| Modifying existing objects | APlayerCharacter& (Reference) |
| Optional objects | AActor* (Pointer with nullptr check) |
| Shared resource management | TSharedPtr |
5. Key Takeaways
- ✅ Use references for guaranteed valid objects.
- ✅ Always mark raw pointers with
UPROPERTY(). - ✅ Prefer smart pointers for complex ownership logic.
6.conclusion
Pointers are like a note with the address of a box(e.g., “Box #42”). That box might exist, be empty, or even have been destroyed! You must check if the address is valid before using it.
Why Are Pointers More Common in Unreal?
Unreal’s dynamic world involves objects (like Actors or Components) that are constantly created, destroyed, or loaded. Pointers:
1. Allow optional relationships (e.g., a weapon without a target).
2. Work seamlessly with Unreal’s garbage collection (via `UPROPERTY()`).
3. Enable polymorphism(e.g., `AActor*` can point to any Actor subclass).
Done! The End! ASK if you Have any issues!