范例 2：与动态复本直接连接

There are no changes to be made on the source side, as a dynamic 复本 only impacts how the requestor node acquires the replica. So, we use the source-side code shown in 范例 1 .

1. Add replica generation to the project.

   Because the replica is dynamically acquired, no .rep file is required unlike in 范例 1 .

2. Create the remote node and connect it to the source host node.

   The code for this step is unchanged from 范例 1 .

   QRemoteObjectNode repNode; // create remote object node
   repNode.connectToNode(QUrl(QStringLiteral("local:switch"))); // connect with remote host node
   							

3. Acquire a replica of the remote source object.

   在 main.cpp ，使用 QSharedPointer to hold a replica of the remote object, and then instantiate a replica requestor object:

   #include <QCoreApplication>
   #include "dynamicclient.h"
   int main(int argc, char *argv[])
   {
       QCoreApplication a(argc, argv);
       QSharedPointer<QRemoteObjectDynamicReplica> ptr; // shared pointer to hold replica
       QRemoteObjectNode repNode;
       repNode.connectToNode(QUrl(QStringLiteral("local:switch")));
       ptr.reset(repNode.acquireDynamic("SimpleSwitch")); // acquire replica of source from host node
       DynamicClient rswitch(ptr); // create client switch object and pass replica reference to it
   }
   							

The complete declaration and definition of the requestor class, DynamicClient , is as follows:

dynamicclient.h

#ifndef _DYNAMICCLIENT_H
#define _DYNAMICCLIENT_H
#include <QObject>
#include <QSharedPointer>
#include <QRemoteObjectNode>
#include <qremoteobjectdynamicreplica.h>
class DynamicClient : public QObject
{
    Q_OBJECT
public:
    DynamicClient(QSharedPointer<QRemoteObjectDynamicReplica> ptr);
    ~DynamicClient();
Q_SIGNALS:
    void echoSwitchState(bool switchState);// this signal is connected with server_slot(..) slot of source object and echoes back switch state received from source
public Q_SLOTS:
    void recSwitchState_slot(); // Slot to receive source state
    void initConnection_slot(); //Slot to connect signals/slot on replica initialization
private:
    bool clientSwitchState; // holds received server switch state
    QSharedPointer<QRemoteObjectDynamicReplica> reptr;// holds reference to replica
 };
#endif
					

dynamicclient.cpp

#include "dynamicclient.h"
// constructor
DynamicClient::DynamicClient(QSharedPointer<QRemoteObjectDynamicReplica> ptr) :
    QObject(nullptr), reptr(ptr)
{
    //connect signal for replica valid changed with signal slot initialization
    QObject::connect(reptr.data(), &QRemoteObjectDynamicReplica::initialized, this,
                     &DynamicClient::initConnection_slot);
}
//destructor
DynamicClient::~DynamicClient()
{
}
// Function to initialize connections between slots and signals
void DynamicClient::initConnection_slot()
{
    // connect source replica signal currStateChanged() with client's recSwitchState() slot to receive source's current state
   QObject::connect(reptr.data(), SIGNAL(currStateChanged()), this, SLOT(recSwitchState_slot()));
   // connect client's echoSwitchState(..) signal with replica's server_slot(..) to echo back received state
   QObject::connect(this, SIGNAL(echoSwitchState(bool)),reptr.data(), SLOT(server_slot(bool)));
}
void DynamicClient::recSwitchState_slot()
{
   clientSwitchState = reptr->property("currState").toBool(); // use replica property to get currState from source
   qDebug() << "Received source state " << clientSwitchState;
   Q_EMIT echoSwitchState(clientSwitchState); // Emit signal to echo received state back to server
}
					

When run together with the source-side example, the output is identical to 范例 1 .