初识单播多播-2020-7-9

单播和原生C

DECLARE_DELEGATE(FDelegateTaskA);
DECLARE_DELEGATE_OneParam(FDelegateTaskB, bool);

DECLARE_DELEGATE_RetVal(bool, FDelegateTaskC);
DECLARE_DELEGATE_RetVal_OneParam(int32, FDelegateTaskD, FString&);

static void Print_f(FString newString)
{
    if (GEngine)
    {
        GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, newString);
    }
}

class ClassA {

public:
    FDelegateTaskA delegateTaskA;
    FDelegateTaskB delegateTaskB;
    FDelegateTaskC delegateTaskC;
    FDelegateTaskD delegateTaskD;

    void Init() {
        bool IsRight = false;
        int32 Index = INDEX_NONE;
        FString NewStr = TEXT("HelloWorld");

        //代理执行
        delegateTaskA.ExecuteIfBound();

        delegateTaskB.ExecuteIfBound(IsRight);

        if (delegateTaskC.IsBound())
        {
            IsRight = delegateTaskC.Execute();
        }

        if (delegateTaskD.IsBound())
        {
            Index = delegateTaskD.Execute(NewStr);
        }

    }
};


class ClassB
{
public:

    ClassB(ClassA* NewClassA) {
        if (NewClassA)
        {
            m_classA = NewClassA;
　　　　　　　　//绑定
            m_classA->delegateTaskA.BindRaw(this, &ClassB::ExecuteA);
            m_classA->delegateTaskB.BindRaw(this, &ClassB::ExecuteB);
            m_classA->delegateTaskC.BindRaw(this, &ClassB::ExecuteC);
            m_classA->delegateTaskD.BindRaw(this, &ClassB::ExecuteD);
            m_classA->Init();
        }

    }

    void ExecuteA() {
        Print_f("ExecuteA");
    }

    void ExecuteB(bool isRight) {
        Print_f("ExecuteB = true");
    }

    bool ExecuteC() {
        Print_f("bool isRight = ExecuteC");
        return false;
    }

    int32 ExecuteD(FString& _str) {
        Print_f("bool IsRight = ExecuteD(true)");
        return 0;
    }

    ~ClassB() {
        if (tempClassA.Get())
        {
            tempClassA->delegateTaskA.Unbind();
            tempClassA->delegateTaskB.Unbind();
            tempClassA->delegateTaskC.Unbind();
            tempClassA->delegateTaskD.Unbind();

            tempClassA->Init();
        }
    }

private:
    ClassA *m_classA;
};

 

void AMyActor::BeginPlay()
{
    Super::BeginPlay();
    
    ClassA* tempA = new ClassA();
    ClassB* tempB = new ClassB(tempA);
    delete tempB;
    tempA = nullptr;
    tempB = nullptr;

}

 

单播和共享指针

class ClassB：public TSharedFromThis<ClassB>
{
public:
    ClassB() {
        tempClassA = MakeShareable(new ClassA());
    }

    void BindDelegate() {
        tempClassA = MakeShareable(new ClassA());

        tempClassA->delegateTaskA.BindRaw(this, &ClassB::ExecuteA);
        //tempClassA->delegateTaskA.BindSP(this, &ClassB::ExecuteA);

        tempClassA->Init();
    }

    void ExecuteA() {
        Print_f("ExecuteA");
    }

    void ExecuteB(bool isRight) {
        Print_f("ExecuteB = true");
    }

    bool ExecuteC() {
        Print_f("bool isRight = ExecuteC");
        return false;
    }

    int32 ExecuteD(FString& _str) {
        Print_f("bool IsRight = ExecuteD(true)");
        return 0;
    }

    ~ClassB() {
        if (tempClassA.Get())
        {
            tempClassA->delegateTaskA.Unbind();
            tempClassA->delegateTaskB.Unbind();
            tempClassA->delegateTaskC.Unbind();
            tempClassA->delegateTaskD.Unbind();

            tempClassA->Init();
        }
    }

    FORCEINLINE TSharedRef <ClassA> GetTempClassA() {
        return tempClassA.ToSharedRef();
    }

private:
    TSharedPtr<ClassA> tempClassA;

};

 

单播和自函数名

TempB->GetTempClassA()->delegateTaskA.BindUFunction(this, TEXT("Print_C"));
    TempB->GetTempClassA()->Init();

 

静态多播，动态单播和多播

需要注意的是，动态需要UObject与反射的支持。

//静态多播
DECLARE_MULTICAST_DELEGATE(FDelegateTaskG);
//动态单播
DECLARE_DYNAMIC_DELEGATE_OneParam(FDelegateTaskE,FString&,str);
//动态多播
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDelegateTaskF,FString&,str);


class ClassA
{
public:
    FDelegateTaskA delegateTaskA;
    FDelegateTaskB delegateTaskB;
    FDelegateTaskC delegateTaskC;
    FDelegateTaskD delegateTaskD;

    FDelegateTaskG delegateTaskG;

    FDelegateTaskE delegateTaskE;
    FDelegateTaskF delegateTaskF;
    void Init()
    {
        bool IsRight = false;
        int32 Index = INDEX_NONE;
        FString NewStr = TEXT("HelloWorld");

        //普通代理执行
        delegateTaskA.ExecuteIfBound();
        delegateTaskB.ExecuteIfBound(IsRight);
        //有返回值
        if (delegateTaskC.IsBound())
        {
            IsRight = delegateTaskC.Execute();
        }
        if (delegateTaskD.IsBound())
        {
            Index = delegateTaskD.Execute(NewStr);
        }

        //多播
        delegateTaskG.Broadcast();
        //动态单播
        delegateTaskE.ExecuteIfBound(NewStr);
        //动态多波
        delegateTaskF.Broadcast(NewStr);

    }
};

UCLASS()
class UTempClassA : public UObject
{
    GENERATED_BODY()

public:

    void InitSelf()
    {
        ClassA* NewClass = new ClassA();

        NewClass->delegateTaskE.BindDynamic(this,&UTempClassA::FunctionA);


        NewClass->delegateTaskF.AddDynamic(this,&UTempClassA::FunctionB);
        NewClass->delegateTaskF.AddDynamic(this,&UTempClassA::FunctionB);
        NewClass->delegateTaskF.AddDynamic(this,&UTempClassA::FunctionB);

        NewClass->Init();


        NewClass->delegateTaskF.Clear();
        NewClass->delegateTaskE.Unbind();
        delete NewClass;
        NewClass=nullptr;
    }

    
    UFUNCTION()
    void FunctionA(FString& str)
    {
        Print_f(TEXT("6666"));
    }

    UFUNCTION()
    void FunctionB(FString& str)
    {
        Print_f(str + TEXT("9999"));
    }
};

 

多态事件代理

class FEventTask
{    
public:
    DECLARE_EVENT_OneParam(FEventTask,FMyTaskA,FString&);
    virtual FMyTaskA &OnEventTaskADeclare()=0;

    DECLARE_EVENT_OneParam(FEventTask,FMyTaskB,FString&);
    FMyTaskB &OnEventTaskBDeclare(){return  TaskB;}


    
    virtual~FEventTask(){}
private:

    FMyTaskB TaskB;

};

class FEventTaskPai:public FEventTask
{
public:
    DECLARE_DERIVED_EVENT(FEventTaskA,FEventTask::FMyTaskA,FMyTaskC);
    virtual FMyTaskC &OnEventTaskADeclare(){return TaskC;}
    void InitMyself()
    {
        FString str = "OnEventTaskBDeclare";
        OnEventTaskBDeclare().Broadcast(str);
        FString str02 = "OnEventTaskBDeclare";
        OnEventTaskBDeclare().Broadcast(str02);
    }

    
private:
    FMyTaskC TaskC;
};


class ATask
{
public:

    void Bind()
    {
        FEventTaskPai* tempClass = new FEventTaskPai();
        tempClass->OnEventTaskBDeclare().AddRaw(this,&ATask::ExecuteA);
        tempClass->OnEventTaskBDeclare().AddRaw(this,&ATask::ExecuteB);
        tempClass->OnEventTaskBDeclare().AddRaw(this,&ATask::ExecuteC);
        tempClass->OnEventTaskBDeclare().AddRaw(this,&ATask::ExecuteD);

        tempClass->InitMyself();

        delete tempClass;
        tempClass=nullptr;

    }
    
    void ExecuteA(FString& newStr)
    {
        Print_f(newStr);
    }

    void ExecuteB(FString& newStr)
    {
        Print_f(newStr);
    }

    void ExecuteC(FString& newStr)
    {
        Print_f(newStr);
    }

    void ExecuteD(FString& newStr)
    {
        Print_f(newStr);
    }
};