Based on the official documentation, this document provides insights into Unreal’s implementation of various smart pointers used in C++. The provided classes include Shared Pointers, Weak Pointers, Unique Pointers, and an additional type known as Shared Reference. Due to separate memory management for UObjects, instances of classes inherited from UObject cannot be wrapped with smart pointers (memory is reclaimed differently, following the RAII pattern).

Types of Pointers

1) Refers to a situation where two or more objects reference each other, preventing each other from being released because the reference count never reaches 0, potentially leading to memory leaks.

Benefits

1) Owners own objects and manage their lifecycles. They can own and release objects using shared pointers and unique pointers when they are no longer needed. Observers reference objects but do not own them (weak pointers). When the owner deletes the object, the observer should become null.

Helper Classes and Functions

Example of using MakeShareable to add additional logic to the destructor:

1
2
3
4
5
6

	TSharedPtr<FOnlineSession> SharedPtr = MakeShareable(new FOnlineSession(), [](FOnlineSession* ObjToDelete)-> void
	{
    	// Custom destructor implementation
		ObjToDelete->PerformAdditionalCleanup();
		delete ObjToDelete;
	});

Detailed Implementation

Unreal’s smart pointers library is implemented with both functionality and efficiency in mind.

Speed

While smart pointers are beneficial in high-level systems like resource management and tool programming, they are not suitable for low-level engine code such as rendering due to performance overhead compared to raw C++ pointers.

Unreal’s smart pointers library provides the following performance advantages:

• All operations are performed in constant time.
• (In shipping builds) Dereferencing in most smart pointers is as fast as raw C++ pointers.
• Copying a smart pointer does not require new memory allocation.
• Thread-safe smart pointers do not require locking.

However, there are some drawbacks as well:

• Creating and copying new smart pointers have overhead compared to raw C++ pointers.
• Managing reference counts adds computational overhead to basic operations.
• Some smart pointers require more memory than raw C++ pointers.
• Reference controllers require two heap memory allocations. Using MakeShared can eliminate the second memory allocation.

Intrusive Accessors

By inheriting TSharedFromThis, a class can obtain accessors for shared pointers that reference it. This allows objects to know which shared pointers are referencing them.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class FRegistryObject;
    class FMyBaseClass: public TSharedFromThis<FMyBaseClass>
    {
        virtual void RegisterAsBaseClass(FRegistryObject* RegistryObject)
        {
            // Access a shared reference to 'this'.
            TSharedRef<FMyBaseClass> ThisAsSharedRef = AsShared();
            RegistryObject->Register(ThisAsSharedRef);
        }
    };
    class FMyDerivedClass : public FMyBaseClass
    {
        virtual void Register(FRegistryObject* RegistryObject) override
        {
            TSharedRef<FMyDerivedClass> AsSharedRef = SharedThis(this);
            RegistryObject->Register(ThisAsSharedRef);
        }
    };
    class FRegistryObject
    {
        void Register(TSharedRef<FMyBaseClass>);
    };

As mentioned, by inheriting TSharedFromThis, a class can use AsShared and SharedThis methods to obtain a shared reference of its instance. Note that the SharedRef method returns a shared reference to the originally specified type in TSharedFromThis, while SharedThis returns a shared reference with the type of ’this’. It is recommended to use the shared pointer of the base class directly when passing shared pointers in method parameters.

Be cautious when using AsShared and SharedThis in constructors, as it may lead to crashes or asserts.

Type Casting

Unreal’s smart pointers library allows casting similar to raw C++ pointers.

• Up Casting: Implicitly performed, allowing a base class pointer to be automatically converted to a derived class pointer.
• Const Casting: Use ConstCastSharedPtr/Ref methods for const casting.
• Static Casting: Use StaticCastSharedPtr/Ref methods for static casting (usually downcasting).
• Dynamic Casting: Dynamic casting is not supported due to the absence of runtime type information (RTTI).

1
2
3
4
5
6

TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();

// Validating that the FDragDropOperation is an FAssetDragDropOp through other means...

// Casting with StaticCastSharedPtr
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);

Thread Safety

By default, smart pointers are only safe in single-threaded environments. If you want a thread-safe version, you can use classes like:

• TSharedPtr<T, ESPMode::ThreadSafe>
• TSharedRef<T, ESPMode::ThreadSafe>
• TWeakPtr<T, ESPMode::ThreadSafe>
• TSharedFromThis<T, ESPMode::ThreadSafe>

These classes perform atomic operations on reference counts, which makes them slightly slower than default classes but operation is very similar to raw C++ pointers.

• Reading and copying operations are always thread-safe.
• Writing and reset operations require synchronization for safety.

Comments

• When passing shared pointers/references as method arguments, there is overhead due to reference counting and dereferencing. If possible, pass by const &.
• Shared pointers allow forward declaration of incomplete types.
• As mentioned, smart pointers and garbage collection in C++ (UObject Handling) are two separate memory management systems.