UniquePtr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/IsArray.h"
#include "Templates/RemoveExtent.h"
#include "Templates/Requires.h"
#include "Serialization/MemoryLayout.h"
#include <type_traits>
 
// Single-ownership smart pointer in the vein of std::unique_ptr.
// Use this when you need an object's lifetime to be strictly bound to the lifetime of a single smart pointer.
//
// This class is non-copyable - ownership can only be transferred via a move operation, e.g.:
//
// TUniquePtr<MyClass> Ptr1(new MyClass);    // The MyClass object is owned by Ptr1.
// TUniquePtr<MyClass> Ptr2(Ptr1);           // Error - TUniquePtr is not copyable
// TUniquePtr<MyClass> Ptr3(MoveTemp(Ptr1)); // Ptr3 now owns the MyClass object - Ptr1 is now nullptr.
//
// If you provide a custom deleter, it is up to your deleter to handle null pointers.  This is a departure
// from std::unique_ptr which will not invoke the deleter if the owned pointer is null:
// https://en.cppreference.com/w/cpp/memory/unique_ptr/~unique_ptr
 
template <typename T>
struct TDefaultDelete
{
    DECLARE_INLINE_TYPE_LAYOUT(TDefaultDelete, NonVirtual);
 
    TDefaultDelete() = default;
    TDefaultDelete(const TDefaultDelete&) = default;
    TDefaultDelete& operator=(const TDefaultDelete&) = default;
    ~TDefaultDelete() = default;
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    TDefaultDelete(const TDefaultDelete<U>&)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    TDefaultDelete& operator=(const TDefaultDelete<U>&)
    {
        return *this;
    }
 
    void operator()(T* Ptr) const
    {
        // If you get an error here when trying to use a TUniquePtr<FForwardDeclaredType> inside a UObject then:
        //
        // * Declare all your UObject's constructors and destructor in the .h file.
        // * Define all of them in the .cpp file.  You can use UMyObject::UMyObject() = default; to auto-generate
        //   the default constructor and destructor so that they don't have to be manually maintained.
        // * Define a UMyObject(FVTableHelper& Helper) constructor too, otherwise it will be defined in the
        //   .gen.cpp file where your pimpl type doesn't exist.  It cannot be defaulted, but it need not
        //   contain any particular implementation; the object just needs to be garbage collectable.
        //
        // If efficiency is less important than simplicity, you may want to consider
        // using a TPimplPtr instead, though it is also pretty efficient.
        delete Ptr;
    }
};
 
template <typename T>
struct TDefaultDelete<T[]>
{
    TDefaultDelete() = default;
    TDefaultDelete(const TDefaultDelete&) = default;
    TDefaultDelete& operator=(const TDefaultDelete&) = default;
    ~TDefaultDelete() = default;
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    TDefaultDelete(const TDefaultDelete<U[]>&)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    TDefaultDelete& operator=(const TDefaultDelete<U[]>&)
    {
        return *this;
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    void operator()(U* Ptr) const
    {
        delete [] Ptr;
    }
};
 
template <typename T, typename Deleter = TDefaultDelete<T>>
class TUniquePtr : private Deleter
{
    DECLARE_INLINE_TYPE_LAYOUT_EXPLICIT_BASES(TUniquePtr, NonVirtual, Deleter);
 
    template <typename OtherT, typename OtherDeleter>
    friend class TUniquePtr;
 
public:
    using ElementType = T;
 
    // Non-copyable
    TUniquePtr(const TUniquePtr&) = delete;
    TUniquePtr& operator=(const TUniquePtr&) = delete;
 
    inline constexpr TUniquePtr()
        : Deleter()
        , Ptr    (nullptr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    explicit inline TUniquePtr(U* InPtr)
        : Deleter()
        , Ptr    (InPtr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    explicit inline TUniquePtr(U* InPtr, Deleter&& InDeleter)
        : Deleter(MoveTemp(InDeleter))
        , Ptr    (InPtr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U*, T*>)
    >
    explicit inline TUniquePtr(U* InPtr, const Deleter& InDeleter)
        : Deleter(InDeleter)
        , Ptr    (InPtr)
    {
    }
 
    inline TUniquePtr(TYPE_OF_NULLPTR)
        : Deleter()
        , Ptr    (nullptr)
    {
    }
 
    inline TUniquePtr(TUniquePtr&& Other)
        : Deleter(MoveTemp(Other.GetDeleter()))
        , Ptr    (Other.Ptr)
    {
        Other.Ptr = nullptr;
    }
 
    template <
        typename OtherT,
        typename OtherDeleter
        UE_REQUIRES(
            !std::is_array_v<OtherT> &&
            std::is_convertible_v<OtherT*, T*>
        )
    >
    inline TUniquePtr(TUniquePtr<OtherT, OtherDeleter>&& Other)
        : Deleter(MoveTemp(Other.GetDeleter()))
        , Ptr    (Other.Ptr)
    {
        Other.Ptr = nullptr;
    }
 
    inline TUniquePtr& operator=(TUniquePtr&& Other)
    {
        if (this != &Other)
        {
            // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this or Other
            T* OldPtr = Ptr;
            Ptr = Other.Ptr;
            Other.Ptr = nullptr;
            GetDeleter()(OldPtr);
        }
 
        GetDeleter() = MoveTemp(Other.GetDeleter());
 
        return *this;
    }
 
    template <
        typename OtherT,
        typename OtherDeleter
        UE_REQUIRES(
            !std::is_array_v<OtherT> &&
            std::is_convertible_v<OtherT*, T*>
        )
    >
    inline TUniquePtr& operator=(TUniquePtr<OtherT, OtherDeleter>&& Other)
    {
        // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this or Other
        T* OldPtr = Ptr;
        Ptr = Other.Ptr;
        Other.Ptr = nullptr;
        GetDeleter()(OldPtr);
 
        GetDeleter() = MoveTemp(Other.GetDeleter());
 
        return *this;
    }
 
    inline TUniquePtr& operator=(TYPE_OF_NULLPTR)
    {
        // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this
        T* OldPtr = Ptr;
        Ptr = nullptr;
        GetDeleter()(OldPtr);
 
        return *this;
    }
 
    UE_FORCEINLINE_HINT ~TUniquePtr()
    {
        GetDeleter()(Ptr);
    }
 
    [[nodiscard]] bool IsValid() const
    {
        return Ptr != nullptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T* operator->() const
    {
        return Ptr;
    }
 
    template <
        typename DummyT = T
        UE_REQUIRES(UE_REQUIRES_EXPR(*(DummyT*)nullptr)) // this construct means that operator* is only considered for overload resolution if T is dereferenceable
    >
    [[nodiscard]] UE_FORCEINLINE_HINT DummyT& operator*() const
    {
        return *Ptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T* Get() const
    {
        return Ptr;
    }
 
    [[nodiscard]] inline T* Release()
    {
        T* Result = Ptr;
        Ptr = nullptr;
        return Result;
    }
 
    inline void Reset(T* InPtr = nullptr)
    {
        if (Ptr != InPtr)
        {
            // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this
            T* OldPtr = Ptr;
            Ptr = InPtr;
            GetDeleter()(OldPtr);
        }
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT Deleter& GetDeleter()
    {
        return static_cast<Deleter&>(*this);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const Deleter& GetDeleter() const
    {
        return static_cast<const Deleter&>(*this);
    }
 
private:
    using PtrType = T*;
    LAYOUT_FIELD(PtrType, Ptr);
 
public:
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() == Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator<(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() < Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator>(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() > Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator<=(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() <= Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator>=(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() >= Rhs.Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR) const
    {
        return !IsValid();
    }
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() != Rhs.Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR) const
    {
        return IsValid();
    }
#endif
 
    friend uint32 GetTypeHash(const TUniquePtr& UniquePtr)
    {
        return GetTypeHash(UniquePtr.Get());
    }
};
 
template <typename T, typename Deleter>
class TUniquePtr<T[], Deleter> : private Deleter
{
    template <typename OtherT, typename OtherDeleter>
    friend class TUniquePtr;
 
public:
    using ElementType = T;
 
    // Non-copyable
    TUniquePtr(const TUniquePtr&) = delete;
    TUniquePtr& operator=(const TUniquePtr&) = delete;
 
    inline constexpr TUniquePtr()
        : Deleter()
        , Ptr    (nullptr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    explicit inline TUniquePtr(U* InPtr)
        : Deleter()
        , Ptr    (InPtr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    explicit inline TUniquePtr(U* InPtr, Deleter&& InDeleter)
        : Deleter(MoveTemp(InDeleter))
        , Ptr    (InPtr)
    {
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    explicit inline TUniquePtr(U* InPtr, const Deleter& InDeleter)
        : Deleter(InDeleter)
        , Ptr    (InPtr)
    {
    }
 
    inline constexpr TUniquePtr(TYPE_OF_NULLPTR)
        : Deleter()
        , Ptr    (nullptr)
    {
    }
 
    inline TUniquePtr(TUniquePtr&& Other)
        : Deleter(MoveTemp(Other.GetDeleter()))
        , Ptr    (Other.Ptr)
    {
        Other.Ptr = nullptr;
    }
 
    template <
        typename OtherT,
        typename OtherDeleter
        UE_REQUIRES(std::is_convertible_v<OtherT(*)[], T(*)[]>)
    >
    inline TUniquePtr(TUniquePtr<OtherT, OtherDeleter>&& Other)
        : Deleter(MoveTemp(Other.GetDeleter()))
        , Ptr    (Other.Ptr)
    {
        Other.Ptr = nullptr;
    }
 
    inline TUniquePtr& operator=(TUniquePtr&& Other)
    {
        if (this != &Other)
        {
            // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this or Other
            T* OldPtr = Ptr;
            Ptr = Other.Ptr;
            Other.Ptr = nullptr;
            GetDeleter()(OldPtr);
        }
 
        GetDeleter() = MoveTemp(Other.GetDeleter());
 
        return *this;
    }
 
    template <
        typename OtherT,
        typename OtherDeleter
        UE_REQUIRES(std::is_convertible_v<OtherT(*)[], T(*)[]>)
    >
    inline TUniquePtr& operator=(TUniquePtr<OtherT, OtherDeleter>&& Other)
    {
        // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this or Other
        T* OldPtr = Ptr;
        Ptr = Other.Ptr;
        Other.Ptr = nullptr;
        GetDeleter()(OldPtr);
 
        GetDeleter() = MoveTemp(Other.GetDeleter());
 
        return *this;
    }
 
    inline TUniquePtr& operator=(TYPE_OF_NULLPTR)
    {
        // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this
        T* OldPtr = Ptr;
        Ptr = nullptr;
        GetDeleter()(OldPtr);
 
        return *this;
    }
 
    UE_FORCEINLINE_HINT ~TUniquePtr()
    {
        GetDeleter()(Ptr);
    }
 
    [[nodiscard]] bool IsValid() const
    {
        return Ptr != nullptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return IsValid();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T& operator[](SIZE_T Index) const
    {
        return Ptr[Index];
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T* Get() const
    {
        return Ptr;
    }
 
    [[nodiscard]] inline T* Release()
    {
        T* Result = Ptr;
        Ptr = nullptr;
        return Result;
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U(*)[], T(*)[]>)
    >
    inline void Reset(U* InPtr)
    {
        // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this
        T* OldPtr = Ptr;
        Ptr = InPtr;
        GetDeleter()(OldPtr);
    }
 
    inline void Reset(TYPE_OF_NULLPTR InPtr = nullptr)
    {
        // We delete last, because we don't want odd side effects if the destructor of T relies on the state of this
        T* OldPtr = Ptr;
        Ptr = InPtr;
        GetDeleter()(OldPtr);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT Deleter& GetDeleter()
    {
        return static_cast<Deleter&>(*this);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const Deleter& GetDeleter() const
    {
        return static_cast<const Deleter&>(*this);
    }
 
private:
    T* Ptr;
 
public:
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() == Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator<(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() < Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator>(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() > Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator<=(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() <= Rhs.Get();
    }
 
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator>=(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() >= Rhs.Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR) const
    {
        return !IsValid();
    }
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    template <typename RhsT>
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TUniquePtr<RhsT>& Rhs) const
    {
        return Get() != Rhs.Get();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR) const
    {
        return IsValid();
    }
#endif
 
    [[nodiscard]] friend uint32 GetTypeHash(const TUniquePtr& UniquePtr)
    {
        return GetTypeHash(UniquePtr.Get());
    }
};
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
template <typename T>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR, const TUniquePtr<T>& Rhs)
{
    return !Rhs.IsValid();
}
 
template <typename T>
[[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR, const TUniquePtr<T>& Rhs)
{
    return Rhs.IsValid();
}
#endif
 
// Trait which allows TUniquePtr to be default constructed by memsetting to zero.
template <typename T>
struct TIsZeroConstructType<TUniquePtr<T>>
{
    enum { Value = true };
};
 
// Trait which allows TUniquePtr to be memcpy'able from pointers.
template <typename T>
struct TIsBitwiseConstructible<TUniquePtr<T>, T*>
{
    enum { Value = true };
};
 
template <
    typename T,
    typename... TArgs
    UE_REQUIRES(!std::is_array_v<T>)
>
[[nodiscard]] UE_FORCEINLINE_HINT TUniquePtr<T> MakeUnique(TArgs&&... Args)
{
    return TUniquePtr<T>(new T(Forward<TArgs>(Args)...));
}
 
template <
    typename T,
    typename... TArgs
    UE_REQUIRES(!std::is_array_v<T>)
>
[[nodiscard]] UE_FORCEINLINE_HINT TUniquePtr<T> MakeUniqueForOverwrite()
{
    return TUniquePtr<T>(new T);
}
 
template <
    typename T
    UE_REQUIRES(TIsUnboundedArray<T>::Value)
>
[[nodiscard]] inline TUniquePtr<T> MakeUnique(SIZE_T Size)
{
    using ElementType = std::remove_extent_t<T>;
    return TUniquePtr<T>(new ElementType[Size]());
}
 
template <
    typename T
    UE_REQUIRES(TIsUnboundedArray<T>::Value)
>
[[nodiscard]] inline TUniquePtr<T> MakeUniqueForOverwrite(SIZE_T Size)
{
    using ElementType = std::remove_extent_t<T>;
    return TUniquePtr<T>(new ElementType[Size]);
}
 
template <
    typename T,
    typename... TArgs
    UE_REQUIRES(TIsBoundedArray<T>::Value)
>
TUniquePtr<T> MakeUnique(TArgs&&... Args) = delete;
 
template <typename T>                   constexpr bool TIsTUniquePtr_V                                        = false;
template <typename T, typename Deleter> constexpr bool TIsTUniquePtr_V<               TUniquePtr<T, Deleter>> = true;
template <typename T, typename Deleter> constexpr bool TIsTUniquePtr_V<const          TUniquePtr<T, Deleter>> = true;
template <typename T, typename Deleter> constexpr bool TIsTUniquePtr_V<      volatile TUniquePtr<T, Deleter>> = true;
template <typename T, typename Deleter> constexpr bool TIsTUniquePtr_V<const volatile TUniquePtr<T, Deleter>> = true;