C++对象之间通信的几种方式

第一种：直接调用（强耦合、循环嵌套）

#include 

using namespace std;

class CouplingB
{
public:
    void HandleMessage(int i)
    {
        cout << i << endl;
    }
};

class CouplingA
{
public:
    void SendMessage(int i)
    {
        m_b.HandleMessage(i);
    }

private:
    CouplingB m_b;
};

int main()
{
    CouplingA coupleingA;
    coupleingA.SendMessage(100);
	return 0;
}
 

第二种：中介者（解耦）

class DecouplingClassA
{
public:
    void SendMessage(int i);
    void HandleMessage(int i)
    {
        cout << "DecouplingClassB::HandleMessage(): " << i << endl;
    }
};

class DecouplingClassB
{
public:
    void SendMessage(int i);
    void HandleMessage(int i)
    {
        cout << "DecouplingClassB::HandleMessage(): " << i << endl;
    }
};

class Mediation
{
private:
    Mediation() {}

public:
    DecouplingClassA GetClassA()
    {
        return m_classA;
    }

    DecouplingClassB GetClassB()
    {
        return m_classB;
    }
public:
    static Mediation* Instance()
    {
        if(nullptr == m_instance)
        {
            m_instance = new Mediation;
        }
        return m_instance;
    }

private:
    DecouplingClassA m_classA;
    DecouplingClassB m_classB;

private:
    static Mediation *m_instance;
};

Mediation *Mediation::m_instance = nullptr;

void DecouplingClassA::SendMessage(int i)
{
    cout << "DecouplingClassA::SendMessage -> ";s

    DecouplingClassB classB = Mediation::Instance()->GetClassB();
    classB.HandleMessage(i);
}

void DecouplingClassB::SendMessage(int i)
{
    cout << "DecouplingClassB::SendMessage -> ";

    DecouplingClassA classA = Mediation::Instance()->GetClassA();
    classA.HandleMessage(i);
}

int main()
{
    // 去耦合（中介器）
    DecouplingClassA classA = Mediation::Instance()->GetClassA();
    classA.SendMessage(200);
    DecouplingClassB classB = Mediation::Instance()->GetClassB();;
    classB.SendMessage(300);
    
    return 0;
}

第三种：回调接口（常用、可扩展成观察者模式）

#ifndef CALLBACK_H
#define CALLBACK_H

#include 
using namespace std;


class Interface
{
public:
    virtual ~Interface() {}
    virtual void Test(int i) = 0;
};

class Invoker
{
public:
    Invoker() {}

    Invoker(Interface *interface)
    {
        m_interface = interface;
    }

    void SetHandler(Interface *interface)
    {
        m_interface = interface;
    }

    void Invoke()
    {
        if(nullptr != m_interface)
            m_interface->Test(500);
    }

private:
    Interface *m_interface;
};

class Realizer : public Interface
{
public:
    Realizer() {}

    void Test(int i)
    {
        cout << "Realizer::test(): " << i << endl;
    }
};

#endif // CALLBACK_H


int main()
{
    // 回调接口
    Realizer *realizer = new Realizer;
    Invoker *invoker = new Invoker(realizer);
    invoker->Invoke();

    return 0;
}

第四种：绑定函数指针

第五种：Qt的信号槽（很强大）