关于 UE4 委托写法

 

Source\CoinCollector\DelegateActor.h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "DelegateActor.generated.h"

// 声明一个没有参数,没有返回值的委托
DECLARE_DELEGATE(FNoParamNoReturn);
// 带参数的委托，给与参数时只需要指定类型
DECLARE_DELEGATE_OneParam(FParam1NoReturn, const FString&);
DECLARE_DELEGATE_TwoParams(FParam2NoReturn, const FString&, float);
// 带参数，并且有返回值的委托
DECLARE_DELEGATE_RetVal_TwoParams(float, FParam2Return, const FString&, float);

UCLASS()
class COINCOLLECTOR_API ADelegateActor : public AActor
{
    GENERATED_BODY()
    
public:    
    // Sets default values for this actor's properties
    ADelegateActor();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;

public:
    FNoParamNoReturn DelegateNoParamNoReturn;            // 使用声明过的委托名称定义一个委托对象
    FParam1NoReturn DelegateOneParamNoReturn;
    FParam2NoReturn DelegateTwoParamNoReturn;
    FParam2Return DelegateTwoParamReturn;

private:
    // 没有参数和返回值的委托函数
    void TestNoParamNoReturn();        
    // 带一个参数和没有返回值的委托函数
    void TestOneParamNoReturn(const FString&);
    // 带两个参数和没有返回值的委托函数
    void TestTwoParamNoReturn(const FString&, float);
    // 带两个参数和 Float 返回值的委托函数
    float TestTwoParamReturn(const FString&, float);

private:
    float TimerMax = 3.f;
    float TimerCount = 0;
};

 

Source\CoinCollector\DelegateActor.cpp

// Fill out your copyright notice in the Description page of Project Settings.

#include "DelegateActor.h"
#include "MoveActor.h"
#include "NewTypes.h"

// Sets default values
ADelegateActor::ADelegateActor()
{
     // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void ADelegateActor::BeginPlay()
{
    Super::BeginPlay();

    // 对于我们需要执行的委托对象,我们需要给他指定存在的真实函数（绑定委托）
    DelegateNoParamNoReturn.BindUObject(this, &ADelegateActor::TestNoParamNoReturn);
    DelegateOneParamNoReturn.BindUObject(this, &ADelegateActor::TestOneParamNoReturn);
    DelegateTwoParamNoReturn.BindUObject(this, &ADelegateActor::TestTwoParamNoReturn);
    DelegateTwoParamReturn.BindUObject(this, &ADelegateActor::TestTwoParamReturn);
}

// Called every frame
void ADelegateActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (TimerCount >= TimerMax)
    {
        DelegateNoParamNoReturn.ExecuteIfBound();　　　　　　　　　　　　　　　　　　　// 执行委托
        DelegateOneParamNoReturn.ExecuteIfBound(TEXT("ABC"));
        DelegateTwoParamNoReturn.ExecuteIfBound(TEXT("ABC"), TimerCount);        // ExecuteIfBound 只能是执行没有返回值的委托
        if (DelegateTwoParamReturn.IsBound())
        {
            TimerCount = DelegateTwoParamReturn.Execute(FString("CDE"),TimerCount);　　　　// 执行有返回值的委托
        }
        else
        {
            UE_LOG(SZYLog, Display, TEXT(" DelegateTwoParamReturn.IsBound() == NULL "));
        }
        UE_LOG(SZYLog, Display, TEXT("TimerCount: %f"), TimerCount);
        UE_LOG(SZYLog, Display, TEXT(" ===================== "));
        TimerCount = 0;
    }
    TimerCount += DeltaTime;
}

void ADelegateActor::TestNoParamNoReturn()
{
    UE_LOG(SZYLog, Display, TEXT("TestNoParamNoReturn Go!!!"));
}

void ADelegateActor::TestOneParamNoReturn(const FString& Param)
{
    UE_LOG(SZYLog, Display, TEXT("TestNoParamNoReturn Go!!! FString: %s"), *Param);
}

void ADelegateActor::TestTwoParamNoReturn(const FString& Param1, float Param2)
{
    UE_LOG(SZYLog, Display, TEXT("TestTwoParamNoReturn Go!!! param1: %s, param2: %f"), *Param1, Param2);
}

float ADelegateActor::TestTwoParamReturn(const FString& Param1, float Param2)
{
    static float Tmp = 0;
    Tmp += Param2;
    UE_LOG(SZYLog, Display, TEXT("TestTwoParamReturn Go!!! param1: %s, param2: %f"), *Param1, Param2);
    if (Tmp >= 30.f)
    {
        // 解委托
        DelegateTwoParamReturn.Unbind();
    }
    return Tmp;
}