Converting Between Smart Pointer Types

In this lesson, you will learn how to safely change the type of your TSharedPtr or TSharedRef instances while maintaining the integrity of Unreal’s reference counting system.

Why Cast Smart Pointers?

In C++, you often have a base class pointer (like TSharedPtr<FBaseItem>) that you know points to a more specific subclass (like TSharedPtr<FWeaponItem>). You cannot simply assign these pointers to each other, even if the types are related. If you force a cast using standard C++ static_cast, you risk breaking the internal reference counting logic, which could lead to double-deletion or memory leaks.

To handle this safely, Unreal Engine provides two specific helper functions: StaticCastSharedPtr and ConstCastSharedPtr.

Using StaticCastSharedPtr

Use StaticCastSharedPtr when you need to perform an "up-cast" or "down-cast" between types that share an inheritance relationship. It performs the cast and returns a new smart pointer that correctly shares the reference count with the original.

TSharedPtr<FBaseItem> BasePtr = MakeShared<FWeaponItem>();

// Safely cast the base pointer to the derived type
TSharedPtr<FWeaponItem> WeaponPtr = StaticCastSharedPtr<FWeaponItem>(BasePtr);

if (WeaponPtr.IsValid())
{
    // Now you can access specific WeaponItem functions
    WeaponPtr->FireWeapon();
}

Using ConstCastSharedPtr

Sometimes, you receive a const smart pointer, but you need to modify the object it points to. ConstCastSharedPtr is the engine-sanctioned way to strip the const qualifier from a smart pointer. It ensures that the underlying reference counting bookkeeping remains untouched while giving you the access you need.

void ModifyItem(TSharedPtr<const FBaseItem> ConstPtr)
{
    // Strip the const qualifier to allow modification
    TSharedPtr<FBaseItem> MutablePtr = ConstCastSharedPtr<FBaseItem>(ConstPtr);
    MutablePtr->SetDurability(100);
}

Important Rule

Never use reinterpret_cast or C-style casts on smart pointers. Smart pointers are wrapper objects; casting the wrapper itself via standard C++ mechanisms ignores the reference count and will cause your game to crash when the objects go out of scope. Always use the provided Unreal helper templates to ensure the reference count stays accurate.

Key Takeaway: Use StaticCastSharedPtr for inheritance-based casting and ConstCastSharedPtr to strip const-qualifiers; these helpers are the only way to safely transition types without corrupting the reference counting system.