智能指针

template< class ObjectType, ESPMode InMode >
class TSharedRef
{
    ObjectType* Object;
    SharedPointerInternals::FSharedReferencer< Mode > SharedReferenceCount;
}

template< ESPMode Mode >
class FSharedReferencer
{
    TReferenceControllerBase<Mode>* ReferenceController;
}

template <ESPMode Mode>
class TReferenceControllerBase
{
    using RefCountType = std::conditional_t<Mode == ESPMode::ThreadSafe, std::atomic<int32>, int32>;
    RefCountType SharedReferenceCount{1};
    RefCountType WeakReferenceCount{1};
}

enum class ESPMode : uint8
{
	/** Forced to be not thread-safe. */
	NotThreadSafe = 0,

	/** Thread-safe, never spin locks, but slower */
	ThreadSafe = 1
};

    //Assignment operator replaces this shared reference with the specified shared reference.
	FORCEINLINE TSharedRef& operator=( TSharedRef const& InSharedRef )
	{
		TSharedRef Temp = InSharedRef;
		::Swap(Temp, *this);
		return *this;
	}

    FORCEINLINE TSharedPtr& operator=( TSharedPtr&& InSharedPtr )
	{
		if (this != &InSharedPtr)
		{
			Object = InSharedPtr.Object;
			InSharedPtr.Object = nullptr;
			SharedReferenceCount = MoveTemp(InSharedPtr.SharedReferenceCount);
		}
		return *this;
	}

    template <typename T>
    struct TUseBitwiseSwap
    {
        // We don't use bitwise operations for 'register' types because this will force them into memory and be slower.
        enum { Value = !(std::is_enum_v<T> || std::is_pointer_v<T> || std::is_arithmetic_v<T>) };
    };

    /**
     * Swap two values.  Assumes the types are trivially relocatable.
     */
    template <typename T>
    inline void Swap(T& A, T& B)
    {
        if constexpr (TUseBitwiseSwap<T>::Value)
        {
            TTypeCompatibleBytes<T> Temp;
            *(TTypeCompatibleBytes<T>*)&Temp = *(TTypeCompatibleBytes<T>*)&A;
            *(TTypeCompatibleBytes<T>*)&A    = *(TTypeCompatibleBytes<T>*)&B;
            *(TTypeCompatibleBytes<T>*)&B    = *(TTypeCompatibleBytes<T>*)&Temp;
        }
        else
        {
            T Temp = MoveTemp(A);
            A = MoveTemp(B);
            B = MoveTemp(Temp);
        }
    }

    /**
     * MoveTemp will cast a reference to an rvalue reference.
     * This is UE's equivalent of std::move except that it will not compile when passed an rvalue or
     * const object, because we would prefer to be informed when MoveTemp will have no effect.
     */
    template <typename T>
    UE_INTRINSIC_CAST FORCEINLINE constexpr std::remove_reference_t<T>&& MoveTemp(T&& Obj) noexcept
    {
        using CastType = std::remove_reference_t<T>;

        // Validate that we're not being passed an rvalue or a const object - the former is redundant, the latter is almost certainly a mistake
        static_assert(std::is_lvalue_reference_v<T>, "MoveTemp called on an rvalue");
        static_assert(!std::is_same_v<CastType&, const CastType&>, "MoveTemp called on a const object");

        return (CastType&&)Obj;
    }