简单基础概念

//FName to FString
	FString str = TEXT("test");
	FName name = FName(str);
//FString to FName 
        FString str = name.ToString();

//std::string to FString
        std::string stdStr = "test";
        FString fStr(stdstr.c_str());
//FString to std::string
        std::string stdStr(TCHAR_TO_UTF8(*fStr));
//FString to int32
        FString fStr = TEXT("test");
        int32 intValue = FCString::Atoi(*fStr);
        //直接用C++ 
        int32 intValue = atoi(TCHAR_TO_UTF8((*fStr)));

//FString to float
        float fValue = FCString::Atof(*fStr);
        fValue = atof(TCHAR_TO_UTF8(*fStr));
//FString to bool
        bool boolValue = fStr.ToBool();
//int to FString
        FString fStr = FString::FromInt(2);
//float to FString
        FString fStr = FString:SanitizeFloat(2.2f);

//FString to char*
        FString fStr(TEXT("test"));
        const TCHAR *charValue = *fStr;
//FString to FText
        FText fText = FText::FromFString(fStr);
//FText to FName
        FName fName = FName(*fText.ToString());
//FString to TArray<uint8>
//先将FString 转换为 char 数组， 再进行遍历
        FString fStr(TEXT("test"));
        TArray<uinit8> targetArr;
        TCHAR *charData = fStr.GetCharArray().GetData();
        int32 len = FCString::StrLen(charData);
        for (int i = 0; i < len; i++) {
                uint8 *dstValue = (uint8 *)TCHAR_TO_UTF8 charData;
                targetArr.Add(*dstValue);
                charData ++;
        }
        // use UE4 api
        FBase64::DeCode(fStr, targetArr);
//TArray<uint8> to FString
        const std::string stdStr((reinterpre_cast<const char *>(targetArr.GetData()), targetArr.GetNum()));
        FString fStr(stdStr.c_str());

//UEnum to FString ，反射用法
        enum ETempEnum {
                test0,
                test1,
                test2
        };
        const UEnum *enumPtr = FindObject<UEnum>(ANY_PACKAGE, TEXT("ETempEnum"), true);
        if (enumPtr) {
                FString str = enumPtr->GetNameStringByIndex(ETempEnum::test1);
        }
//FString to UEnum
         const UEnum *enumPtr = FindObject<UEnum>(ANY_PACKAGE, TEXT("ETempEnum"), true);
        if (enumPtr) {
                ETempEnum enumVal = (ETempEnum)enumPtr->GetIndexByNameString(TEXT"test1");
        }

DECLARE_DELETGATE(testDelegate);
DECLARE_DELEGATE_TwoParams(testDelegate, float , const FString &);
//C++ lambda
// 　C++11提供了对匿名函数的支持,称为Lambda函数(也叫Lambda表达式). Lambda表达式具体形式如下:

// 　　　　[capture](parameters)->return-type{body}

// 　　如果没有参数,空的圆括号()可以省略.返回值也可以省略,如果函数体只由一条return语句组成或返回类型为void的话.形如:

// 　　 　 [capture](parameters){body}

//cpp文件开头
DECLARE_DELEGATE_RetVal_TwoParams(int32, FDelegateTwoParams, float, const FString &);

//cpp class中声明一个对应代理类型的变量
FDelegateTwoParmas fDelegate;

//eg. 在Actor类中BeginPlaty方法中绑定，这里第一个参数传 this 是因为写在类里的成员方法中，要绑定自己对应类中的方法
//绑定一个继承自UObject的类里的方法
fDelegate::BindUObject(this, &your_corresponding_function);
//eg.绑定lambda
fDelegate::BindLamda([this](float fVal, const FString &s)->int32 {
        return 0;
});
//eg.绑定C++ 原生方法
//声明一个类A的对象a
A a;
fDelegate::BindRaw(&a, &A::funcA);
//eg. 绑定共享指针
//声明一个指向A类型对象的共享指针
TSharedPtr<A> aPtr = MakeSharable<new A>;
fDelegate::BindSP(aPtr.ToSharedRef(), &A::funcA);
//eg. 绑定一个静态函数
fDelegate::BindStatic(&your_static_func_name);
//Binds a shared pointer-based (slower, conditionally thread-safe) member function delegate.
TSharedPtr<A, ESPMode::ThreadSafe> aPtr1 = MakeSharable(new A);
fDelegate::BindThreadSafeSP(aPtr1.ToSharedRef(). &A::funcA);
//eg.通过函数名找到函数并绑定到代理
fDelegate::BindUFunction(this, FName("your_function_name_in_this_class"));

//执行时需要判断是否绑定
if (fDelegate.IsBond()) {
        fDelegate.Excute(11, "ddd");
}
// no return val you can call
fDelegate.ExecuteIfBound()

fDelegate.Unbind();

//声明
DECLARE_MULTICAST_DELEGATE_TwoParms(FMultiDelegate, float a, const FString &fStr);
//绑定函数时使用的是AddXXX 
FMultiDelegate.AddUObject(this, &A::funcA);
// 执行时利用广播，不需要判断是否有效
FMultiDelegate.Broadcast(33f, "test");

//通过使动态单播代理作为函数参数的形式将其暴露给蓝图
UFUNCTION(BlueprintCallable)
void testdynamicdelegate(FDynamicDelegate fdynamicdelegate);

//声明
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FDyMuDelegate);
//绑定函数
//注意需要绑定的函数必须声明为UFUNTION()，因为动态代理支持将其暴露给蓝图使用
UFUNCTION(BluprintAssianable)
FDyMuDelegate fDelegate;
//打开关卡蓝图，可以对actor 绑定事件

FSoftObjectPath AssetPath(TEXT("/Game/Mannequin/Animations/ThirdPersonWalk.ThirdPersonWalk"));
FStreamableManager& AssetLoader = UAssetManager::GetStreamableManager();
//hold object in memory.TSharedPtr<FStreamableHandle> Handle = AssetLoader.RequestSyncLoad(AssetPath, true);
UObject* Obj = Handle->GetLoadedAsset();
//free memory of object.Handle->ReleaseHandle();

{
    FGCObjectScopeGuard(UObject* GladOS = NewObject<...>(...));
    GladOS->SpawnCell();
    RunGC();
    GladOS->IsStillAlive();   // Object will not be removed by GC
}

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UCoolDownComponent")
        TArray<UCoolDown*>      mCDArr;

    UCoolDown* cd = NewObject<UCoolDown>(_class);
    cd->SetSkillId(_skillId);
    mCDArr.Add(cd);

UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MyChar")
       TMap<int32, UBehavData*> mTestMap2;

UBehavData* bh = NewObject<UBehavData>(this, UBehavData::StaticClass());
bh->mId = 111;
mTestMap2.Add(111, bh);
bh = NewObject<UBehavData>(this, UBehavData::StaticClass());
bh->mId = 222;
mTestMap2.Add(222, bh);

if(!MyObject) return; 
if(!MyObject->IsValidLowLevel()) return;
MyObject->ConditionalBeginDestroy(); //instantly clears UObject out of memory 
MyObject = nullptr; 

if(!TheCharacter) return; 
if(!TheCharacter->IsValidLowLevel()) return;
 TheCharacter->Destroy(); 
TheCharacter->ConditionalBeginDestroy(); //essential extra step, in all my testing 

 virtual void PostActorCreated() override; //做初始化工作
   virtual void BeginPlay() override; //做初始化工作
   virtual void BeginDestroy() override; //引擎在gc的时候调用，并不是立即调用，一般不用
   virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override; //做清理工作
   virtual void Destroyed() override; //用于释放成员，调用Destroy();会立即调用

// Begin UActorComponent Interface.
virtual void BeginPlay() override; //组件RegisterComponent注册的时候，且有OwnerActor才会立即调用，一般不用
virtual void BeginDestroy() override; //引擎在gc的时候调用，并不是立即调用，一般不用
virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override; //立即调用，一般这里做清理工作（注册过才会调用），且gc时还会再调用一次，一般不用
virtual void OnComponentCreated() override; //组件RegisterComponent注册的时候立即调用，一般这里做初始化工作
virtual void OnComponentDestroyed(bool bDestroyingHierarchy) override;//立即调用，一般这里做清理工作（只要DestroyComponent就会调用）