Mit dem Botschafts-Manager "TMessageManager" in der unit "System.Messaging" bietet die Delphi RTL eine plattformübergreifende Möglichkeit Botschaften zu verarbeiten.

Die zu verabeitenden Nachrichten müssen alle von der Basisklasse TMessage abgeleitet werden, die in der unit "System.Messaging" definiert ist *). Benutzerdefinierte Botschaften werden unter Verwendung eines generischen TMessage Typs definiert:

TMessage = class (TMessage)

Die weitern Schritte, die Bereitstellung der Instanz eines Botschaften-Managers, der Abonnierung von Botschaftentypen und schließlich dem Senden der Botschaften werden in der Embarcadero Dokumentation beschrieben. (Die Links gibt es hier nicht, weil sie häufig wechseln. Aber sie sind leicht zu finden.)

Hier wird der gesamte Delphi Code des Beispiels wiedergegeben:

unit Unit1;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Graphics, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.StdCtrls,
  System.Messaging, FMX.Edit;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form2: TForm1;

implementation

{$R *.fmx}

procedure TForm1.Button1Click(Sender: TObject);
var
  MessageManager: TMessageManager;
  Message: TMessage;
begin
  MessageManager := TMessageManager.DefaultManager;
  Message := TMessage.Create(Edit1.Text);
  MessageManager.SendMessage(Sender, Message, True);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  SubscriptionId: Integer;
  MessageManager: TMessageManager;
begin
  MessageManager := TMessageManager.DefaultManager;
  SubscriptionId := MessageManager.SubscribeToMessage(TMessage, procedure(const Sender: TObject; const M: TMessage)
  begin
    ShowMessage((M as TMessage).Value);
  end);
end;

end.

Dieser Code lässte sich mit Delphi2Cpp direkt in den entsprechenden C++ Code übersetzten:

#ifndef Unit1H
#define Unit1H

#include "System.h"
#include "d2c_system.h"

#include "Winapi.Windows.h"
#include "Winapi.Messages.h"
#include "System.SysUtils.h"
#include "System.Variants.h"
#include "System.Classes.h"
#include "Vcl.Graphics.h"
#include "Vcl.Controls.h"
#include "Vcl.Forms.h"
#include "Vcl.Dialogs.h"
#include "Vcl.StdCtrls.h"

class TForm1 : public Vcl::Forms::TForm
{
public:
  typedef Vcl::Forms::TForm inherited;
  typedef System::ClassRef ClassRefType;  
  ClassRefType* ClassType() const {return  System::class_id();}
  TForm1* Create() const {return new TForm1();}
  static TForm1* SCreate() {return new TForm1();}
  System::String ClassName() const {return L"TForm1";}
  static System::String SClassName() {return L"TForm1";}
public:
  Vcl::Stdctrls::TButton* Button1;
  Vcl::Stdctrls::TEdit* Edit1;
  void Button1Click(TObject* Sender);
  void FormCreate(TObject* Sender);
private:
    /* Private-Deklarationen */
public:
    /* Public-Deklarationen */
  void InitMembers(){Button1 = nullptr; Edit1 = nullptr;}
  TForm1(System::Classes::TComponent* AOwner);
  TForm1(HWND parentWindow);
  TForm1();
};
extern TForm1* Form1;
#endif // Unit1H

#include "pch.h"

#include "Unit1.h"
#include "System.Messaging.h"

using namespace std;
using namespace System;
using namespace System::Classes;
using namespace System::Messaging;
using namespace Vcl::Dialogs;
using namespace Vcl::Forms;
using namespace Vcl::Stdctrls;

TForm1::TForm1(System::Classes::TComponent* AOwner) : inherited(AOwner) {InitMembers();}
TForm1::TForm1(HWND parentWindow) : inherited(parentWindow) {InitMembers();}
TForm1::TForm1() {InitMembers();}

TForm1* Form1 = nullptr;
//#pragma resource /* "*.dfm" */ 

// https://docwiki.embarcadero.com/CodeExamples/Alexandria/en/System.Messaging_(Delphi)
// https://docwiki.embarcadero.com/CodeExamples/Alexandria/en/System.Messaging_(C%2B%2B)

void TForm1::Button1Click(TObject* Sender)
{
  TMessageManager* MessageManager = nullptr;
  System::Messaging::TMessage* Message = nullptr;
  MessageManager = TMessageManager::ReadPropertyDefaultManager();
  Message = new TMessage__1(Edit1->ReadPropertyText());
  MessageManager->SendMessage(Sender, Message, true);
}

void TForm1::FormCreate(TObject* Sender)
{
  int SubscriptionId = 0;
  TMessageManager* MessageManager = nullptr;
  MessageManager = TMessageManager::ReadPropertyDefaultManager();
  SubscriptionId = (int) MessageManager->SubscribeToMessage(class_id>(), [&](TObject* const Sender,    System::Messaging::TMessage* const m) -> void 
  {
    ShowMessage(((TMessage__1*) m)->ReadPropertyValue());
  });
}

C++Builder

Die Überstzung für den C++Builder weicht von diesem Code darin ab, dass statt des Basistype TMessage der Typ TMessageBase verwendet werden muss. Das gelingt, indem man für den nicht-generischen TMessage-Typ ein Refactoring nach TMessageBase definiert.

In der Embarcadero Dokumentation gibt es auch den Beispielescode für den C++Builder. Dort wird anstelle der anonymen Methode extra ein Methode in TForm1 definiert. Mit dem moderne C++Compiler im RAD Studio Alexandira ist dies nicht mehr nötig. Der übersetzte Code für den C++Builder funktioniert ohne weitere Nachbearbeitung.

Für den C++Builder wir als Schlüssel für die abbonnierten Methoden die __classid des Botschaftstyps verwendet. Für andere Compiler gibt es dieses spezielle Schlüsselwort nicht. Stattdessen wird hier die Simulation mittels der class_id-Funktion verwendet.

*) Ein Problem besteht darin, dass es eine weitere TMessage Klasse gibt, die in der unit "Winapi.Messages" definiert sind. Für den C++Builder müssen Nachrichtenklassen daher nicht von TMessage sondern von TMessageBase abgeleitet sein.