Question

我想实现一种解决方法，使用非静态类作为回调函数。我正在使用Eclipse Paho MQTT代码。实现以下类型并将其用作回调：

typedef void MQTTAsync_onSuccess(void* context, MQTTAsync_successData* response);

MQTTAsync_onSuccess* onSuccess;

onSuccess = myStaticCallback;

void myStaticCallback (void* context, MQTTAsync_successData* response)
{
   //...callback actions...
}

我想包装这个C API（不修改现有的MQTT C API）并实现属于对象/类的非静态/非集中式回调函数。

typedef void MQTTAsync_onSuccess(void* context, MQTTAsync_successData* response);

class myMQTTClass
{
   private:
      void myCallback (void* context, MQTTAsync_successData* response);
      MQTTAsync_onSuccess* onSuccess;

   public:
      void foo (void)
      {
          this->onSuccess = this->myCallback;
      }
}

正如您可能猜到的，上面的代码会导致错误：无法将myCallback从'void (myMQTTClass::) (void*, MQTTAsync_successData*)'类型转换为'void (*)(void*, MQTTAsync_successData*)'类型。

非常感谢有关如何解决此问题或任何解决方法的任何指导。我愿意提供任何可能缺少的信息。提前谢谢。

编辑：有一些遗漏的实际代码

   namespace rover
    {
       typedef struct
       {
        char * clientID;
        char * topic;
        char * payload;
        int         qos;        // 1
        long int    timeout;    // Such as 10000L usec
       } RoverMQTT_Configure_t;

       class RoverPahoMQTT
       {
           public:
              RoverPahoMQTT (char * host_name, int port, RoverMQTT_Configure_t MQTT_Configure);

           private:

             /**
             * @brief Host name used for connecting to the Eclipse Paho MQTT server
             */
            char * HOST_NAME;

            /**
             * @brief Port used for connecting to the Eclipse Paho MQTT server
             */
            int PORT;

            RoverMQTT_Configure_t rover_MQTT_configure;

            /* Internal attributes */
            MQTTAsync client;

            /**
             * @brief Connect options
             */
            MQTTAsync_connectOptions conn_opts;

            /**
             * @brief Disconnect options
             */
            MQTTAsync_disconnectOptions disc_opts;

             //...
             static void onPublisherConnect (void* context, MQTTAsync_successData* response);
             void onPublisherConnect_ (MQTTAsync_successData* response);

           //...

       }
    }

    int rover::RoverPahoMQTT::publish (void)
    {
        this->flushFlags ();

        this->conn_opts = MQTTAsync_connectOptions_initializer;
        this->client = new MQTTAsync;
        int rc;

        char my_addr[20];
        this->constructAddress (my_addr);
        printf ("address: %s", my_addr);
        MQTTAsync_create (  &(this->client),
                            my_addr,
                            this->rover_MQTT_configure.clientID,
                            MQTTCLIENT_PERSISTENCE_NONE,
                            NULL);

        MQTTAsync_setCallbacks(this->client, NULL, onConnectionLost, NULL, NULL);

        conn_opts.keepAliveInterval = 20;
        conn_opts.cleansession = 1;
        conn_opts.onSuccess = rover::RoverPahoMQTT::onPublisherConnect;
        conn_opts.onFailure = onConnectFailure;
        conn_opts.context = this->client;

        if ((rc = MQTTAsync_connect(this->client, &(this->conn_opts))) != MQTTASYNC_SUCCESS)
        {
            printf("Failed to start connect, return code %d\n", rc);
            return rc;
        }

        /*printf("Waiting for publication of %s\n"
             "on topic %s for client with ClientID: %s\n",
             PAYLOAD, TOPIC, CLIENTID);*/
        while (!mqtt_finished)
            usleep(this->rover_MQTT_configure.timeout);

        MQTTAsync_destroy(&client);
        return rc;
    }

    void rover::RoverPahoMQTT::onPublisherConnect_(MQTTAsync_successData* response)
    {
        MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
        MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
        int rc;

        printf("Successful connection\n");

        opts.onSuccess = onPublisherSend;
        opts.context = client;

        pubmsg.payload = &default_MQTT_configure.payload;
        pubmsg.payloadlen = strlen(default_MQTT_configure.payload);
        pubmsg.qos = default_MQTT_configure.qos;
        pubmsg.retained = 0;
        deliveredtoken = 0;

        if ((rc = MQTTAsync_sendMessage(client, default_MQTT_configure.topic, &pubmsg, &opts)) != MQTTASYNC_SUCCESS)
        {
            printf("Failed to start sendMessage, return code %d\n", rc);
            exit(EXIT_FAILURE);
        }
    }

    void rover::RoverPahoMQTT::onPublisherConnect (void* context, MQTTAsync_successData* response)
    {
        rover::RoverPahoMQTT* m = (rover::RoverPahoMQTT*) context;
        m->onPublisherConnect_(response);
        //((rover::RoverPahoMQTT*)context)->onPublisherConnect_(response);
        // ^^^HERE IS THE SEGMENTATION FAULT

    }

Answer 1

如果你可以使用context参数指向你想要回调的对象，你可以简单地使回调函数静态并转发到实例函数。如果其他数据需要context参数，那么我将使用libffi生成一个闭包，并将对象指针与闭包的已保存参数相关联。

没有正确的方法将实际的实例函数传递给该回调，并确保它可以正常工作（即使你使实例函数类似于void MyCallback（MQTTAsync_successData *），然后强行将其转换为回调类型你不能保证调用约定会匹配。

对于第一个（您可以使用上下文arg指向'this'）：

jpg

然后，您可以将＆amp; MyCallback :: CallbackFunc分配给函数指针。

libffi相当复杂。

Answer 2

如明确指出here，回调必须是

通过将其作为参数传递给客户端库进行注册 MQTTAsync_responseOptions

并且context参数是

指向最初传递给的上下文值的指针 MQTTAsync_responseOptions，包含任何特定于应用程序的上下文。

我建议为您的类提供一个通用接口，它提供了一个与回调原型匹配的静态方法：

class myMQTTClass
{
public:
  static void callback(void* context, MQTTAsync_successData* response)
  {
    myMQTTClass * m = (myMQTTClass*)context;
    m->myCallback(response);
  }
protected:
  virtual void myCallback(MQTTAsync_successData* response) = 0;
};

您现在可以在子类中实现不同的行为：

class myMQTTClassImpl : public myMQTTClass
{
protected:
  void myCallback(MQTTAsync_successData *response)
  {
    std::cout << "success!!!" << std::endl;
  }
};

让我们看看如何使用它：

int main()
{
  myMQTTClass * m = new myMQTTClassImpl();

  MQTTAsync_responseOptions options;
  options.onSuccess = myMQTTClass::callback;
  options.context = m;
}

编辑（指实际发布的代码）：

在publish方法中，这是正确的：

conn_opts.onSuccess = rover::RoverPahoMQTT::onPublisherConnect;

这是错误的：

conn_opts.context = this->client;

它应该是：

conn_opts.context = this;

在C ++中实现类中的回调函数

2 个答案: