UE4C++ 委托

2020-11-15

委托

概念： 委托是一种泛型但类型安全的方式，可在C++对象上调用成员函数。虚幻引擎共支持三种类型的委托：单点委托、组播委托、动态委托
作用：1）泛型但类型安全；
2）可使用委托动态绑定到任意对象的成员函数，之后在该对象上调用函数，即使调用程序不知对象类型也可进行操作。
3）复制委托对象很安全；
4）可以利用值传递委托，但这样操作需要在堆上分配内存，因此通常并不推荐，请尽量通过引用传递委托。
使用方式：声明委托、绑定委托、执行委托

类比：调用委托——顾客点外卖指定某个餐馆（委托），绑定委托——餐馆（委托）指名（绑定到）某个员工（对象）去送餐（对象的成员函数），执行委托——员工送餐（调用对象的成员函数）

声明委托

如需声明委托，需使用宏。根据与委托相绑定的函数（或多个函数）的函数签名来选择宏。每个宏都为新的委托类型名称、函数返回类型（如果不是 void 函数）及其参数提供了参数。

当前，支持以下使用任意组合的委托签名：

• 返回一个值的函数。
• 声明为 常 函数。
• 最多4个"载荷"变量。
• 最多8个函数参数。

绑定委托

委托制造的类中：
DECLARE_DELEGATE(FTestDelegate);               //委托声明
DECLARE_DELEGATE_RetVal(bool, FTestDelegate_Ret);
DECLARE_DELEGATE_OneParam(FTestDelegate_Bool, bool);    

UENUM(BlueprintType)                      //委托类型
enum class EDelegateType:uint8
{
	Object,
	Lambda,
	Raw,
	SP,
	Static,
	WeakLambda,
	UFunction,
};

UCLASS()
class DELEGATETEST_API UDelegateMakerObject : public UObject
{
	GENERATED_BODY()
public:
	FTestDelegate& MakeDelegate(EDelegateType);    //制造委托的函数

	FTestDelegate_Ret& MakeDelegate_Ret();

	FTestDelegate_Bool& MakeDelegate_Payload(int param);

	FTestDelegate Delegate;
	FTestDelegate_Ret Delegate_Ret;
	FTestDelegate_Bool Delegate_Bool;

	TSharedPtr<class RawObject> RawObjectPtr;
	class UDelegateObject* UEObject = nullptr;
};

FTestDelegate& UDelegateMakerObject::MakeDelegate(EDelegateType Type)
{
	if (Delegate.IsBound())
	{
		Delegate.Unbind();
	}
	switch (Type)
	{
	case EDelegateType::Object:                 //绑定对象，最常见
		if (UEObject==nullptr)
		{
			UEObject = NewObject<UDelegateObject>();
		}
		Delegate.BindUObject(UEObject, &UDelegateObject::TestDelegate);
		break;
	case EDelegateType::Lambda:                 //绑定lambda表达式，可以没有对象
		Delegate.BindLambda
		(
			[](void)                            //纯粹的匿名函数
			{
				UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__));
			}
		);
		break;
	case EDelegateType::Raw:                       //绑定原始类的对象
		if (!RawObjectPtr.IsValid())                                  
		{
			RawObjectPtr = MakeShareable(new RawObject);
		}
		Delegate.BindRaw(RawObjectPtr.Get(), &RawObject::DelegateTest);
		break;
	case EDelegateType::SP:                          //绑定智能指针
		if (!RawObjectPtr.IsValid())
		{
			RawObjectPtr = MakeShareable(new RawObject);
		}
		Delegate.BindSP(RawObjectPtr.ToSharedRef(), &RawObject::DelegateTest);
		break;
	case EDelegateType::Static:                      //绑定静态函数，不需要对象
		Delegate.BindStatic(&RawObject::DelegateStatic);
		break;
	case EDelegateType::UFunction:                 //绑定UE4对象的UFUNCTION,特点是依靠函数名找到函数
		if (UEObject == nullptr)
		{
			UEObject = NewObject<UDelegateObject>();
		}
		Delegate.BindUFunction(UEObject, "TestDelegateUFunction");
		break;
	case EDelegateType::WeakLambda:                //绑定弱的lambda表达式
		if (UEObject == nullptr)
		{
			UEObject = NewObject<UDelegateObject>();
		}
		Delegate.BindWeakLambda(UEObject, [](void){ UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__)); });  
		//相较原先lambda，多了一步检查UEObject是否有效。若无效，则停止
		break;
	default:
		break;
	}
	return Delegate;
}

class RawObject                        //原始类，不继承UE4的类
{
public:
	void DelegateTest()
	{
		UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__));
	}
	static void DelegateStatic()
	{
		UE_LOG(LogTemp, Warning, TEXT(__FUNCTION__));
	}

};

调用委托