C++ 如何在两个类之间发送/接收消息

我有两个类source和destination，它们代表我希望在它们之间发送和接收消息的两个主机。为此，我创建了以下类。有更好的方法吗？ 例如：

       class   Reseux
  {
   private:
         int Nb_Source;
         int Nb_destination;

   public:
          class  Source
                {
                 private:
                         int id_Source;

                 public:
                      void __fastcall Envoyer();
                      void __fastcall Recevoir();
                      int __fastcall get_id() {return (this->id_Source);};
                } *Source;
        //---------------------------------------------------------------- 
          class  destination;
                {
                 private:
                         int id_destination;;

                 public:
                      void __fastcall Envoyer();
                      void __fastcall Recevoir();
                      int __fastcall get_id() {return (this->id_destination);};
                } *destination;              
  };
  class tMessage
  {
   private:
           String Contenu;
           int id_Source, id_Destination;
   public:
          bool Alert;
          int __fastcall get_id_Source() {return(this->id_Source);};
          int __fastcall get_id_Destination() {return(this->id_Destination);};
  };
void __fastcall Reseux::Source::Envoyer(tMessage *_Message)
{   _Message=new tMessage();
_Message->id_Source=Source->get_id();
_Message->id_destination=id_destination->get_id();
 destination->Recevoir(_Message);}
void __fastcall Reseux::destination::Recevoir(tMessage *_Message)
{   };

---

您可以尝试观察者模式，如下所示：

#include <string>
#include <iostream>
#include <memory>
#include <vector>

class Message
{
public:
    explicit Message(const std::string& text) : content(text) { }

    std::string GetText() const { return content; }

private:
    std::string content{ "" };
};

class Subscriber
{
public:
    explicit Subscriber() { }
    virtual ~Subscriber() { }

    virtual void ReceiveMsg(const Message& msg) = 0;
};

class Source
{
public:
    explicit Source() { }

    inline void BroadcastMsg(const std::string& content)
    {
        Message msg(content);

        for (const auto& subscriber : subscribers)
            subscriber->ReceiveMsg(msg);
    }

    inline void AddSubscriber(Subscriber* sub) { subscribers.push_back(sub); }

private:
    std::vector<Subscriber*> subscribers;
};

class Destination : public Subscriber
{
public:
    explicit Destination() { }
    virtual ~Destination() { }

    inline virtual void ReceiveMsg(const Message& msg) override 
    {
        std::cout << msg.GetText();
    }
};

int main()
{
    std::unique_ptr<Source> host1 = std::make_unique<Source>();
    std::unique_ptr<Destination> host2 = std::make_unique<Destination>();
    host1->AddSubscriber(host2.get());
    host1->BroadcastMsg("Good morning, Vietnam!!!");
    getchar();
}

#包括
#包括
#包括
#包括
类消息
{
公众：
显式消息（const std:：string和text）：内容（text）{}
std:：string GetText（）常量{return content；}
私人：
std：：字符串内容{“”}；
};
类订户
{
公众：
显式订阅服务器（）{}
虚拟~Subscriber（）{}
虚空接收消息（const Message&msg）=0；
};
类源
{
公众：
显式源（）{}
内联void BroadcastMsg（const std:：string&content）
{
消息消息（内容）；
用于（常数自动和订户：订户）
订户->接收消息（消息）；
}
inline void AddSubscriber（Subscriber*sub）{subscribers.push_back（sub）；}
私人：
std：：向量订户；
};
类别目的地：公共订户
{
公众：
显式目标（）{}
虚拟~Destination（）{}
内联虚空接收消息（常量消息和消息）覆盖
{
std:：coutaddsubscriber（host2.get（））；
host1->BroadcastMsg（“早上好，越南！！！”）；
getchar（）；
}

在程序中有不同的通信方式。其中一种方式是使用多线程。我建议您在线阅读更多关于多线程编程的内容，或者阅读一些有关此任务的教科书。