PahoMQTT分配事件 我用Paho MQTT作为C++，我试图把类方法分配为事件。当在类之外分配方法时，它是有效的，但当从类中分配方法时，我会遇到以下异常： In file included from /home/void/Documents/Projects/Manufacturer/Server.cpp:5: /home/void/Documents/Projects/Manufacturer/Server.h:19:10: note: declared here void connectionLost(void *context, char *cause); ^~~~~~~~~~~~~~ /home/void/Documents/Projects/Manufacturer/Server.cpp:23:27: error: cannot convert ‘Server::onConnect’ from type ‘void (Server::)(void*, MQTTAsync_successData*)’ to type ‘void (*)(void*, MQTTAsync_successData*)’ conn_opts.onSuccess = onConnect; ^~~~~~~~~ /home/void/Documents/Projects/Manufacturer/Server.cpp:24:27: error: cannot convert ‘Server::onConnectFailure’ from type ‘void (Server::)(void*, MQTTAsync_failureData*)’ to type ‘void (*)(void*, MQTTAsync_failureData*)’ conn_opts.onFailure = onConnectFailure; ^~~~~~~~~~~~~~~~ /home/void/Documents/Projects/Manufacturer/Server.cpp: In member function ‘void Server::onConnect(void*, MQTTAsync_successData*)’: /home/void/Documents/Projects/Manufacturer/Server.cpp:94:22: error: cannot convert ‘Server::onSubscribe’ from type ‘void (Server::)(void*, MQTTAsync_successData*)’ to type ‘void (*)(void*, MQTTAsync_successData*)’ opts.onSuccess = onSubscribe; ^~~~~~~~~~~ /home/void/Documents/Projects/Manufacturer/Server.cpp:95:22: error: cannot convert ‘Server::onSubscribeFailure’ from type ‘void (Server::)(void*, MQTTAsync_failureData*)’ to type ‘void (*)(void*, MQTTAsync_failureData*)’ opts.onFailure = onSubscribeFailure; ^~~~~~~~~~~~~~~~~~

如何创建事件类方法

Server.cpp

#include "Server.h"

Server::Server(const char *manufacturerID) {
    this->manufacturerID = manufacturerID;

    MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
    MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
    MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
    MQTTAsync_token token;
    int rc;
    int ch;

    MQTTAsync_create(&this->MQTTclient, "tcp://127.0.0.1:1883", manufacturerID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
    MQTTAsync_setCallbacks(this->MQTTclient, NULL, connectionLost, messageArrived, NULL);

    conn_opts.keepAliveInterval = 20;
    conn_opts.cleansession = 1;

    conn_opts.onSuccess = onConnect;
    conn_opts.onFailure = onConnectFailure;
    conn_opts.context = this->MQTTclient;
    if ((rc = MQTTAsync_connect(this->MQTTclient, &conn_opts)) != MQTTASYNC_SUCCESS)
    {
        printf("Failed to start connect, return code %d\n", rc);
        exit(-1);
    }

}



int Server::messageArrived(void *context, char *topicName, int topicLen, MQTTAsync_message *message)
{
    int i;
    char* payloadptr;

    printf("Message arrived\n");
    printf("     topic: %s\n", topicName);
    printf("   message: ");

    payloadptr = (char*) message->payload;
    for(i=0; i<message->payloadlen; i++)
    {
        putchar(*payloadptr++);
    }
    putchar('\n');
    MQTTAsync_freeMessage(&message);
    MQTTAsync_free(topicName);
    return 1;
}

void Server::connectionLost(void *context, char *cause)
{
    MQTTAsync client = (MQTTAsync)context;
    MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
    int rc;

    printf("\nConnection lost\n");
    printf("     cause: %s\n", cause);

    printf("Reconnecting\n");
    conn_opts.keepAliveInterval = 20;
    conn_opts.cleansession = 1;
    if ((rc = MQTTAsync_connect(client, &conn_opts)) != MQTTASYNC_SUCCESS)
    {
        printf("Failed to start connect, return code %d\n", rc);
        finished = 1;
        return;
    }
}

void Server::onConnectFailure(void* context, MQTTAsync_failureData* response)
{
    printf("Connect failed, rc %d\n", response ? response->code : 0);
    finished = 1;
}


void Server::onConnect(void* context, MQTTAsync_successData* response)
{
    MQTTAsync client = (MQTTAsync)context;
    MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
    MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
    int rc;

    printf("Successful connection\n");

    printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
           "Press Q<Enter> to quit\n\n", "SensorData", this->manufacturerID, 1);
    opts.onSuccess = onSubscribe;
    opts.onFailure = onSubscribeFailure;
    opts.context = client;

    deliveredtoken = 0;

    if ((rc = MQTTAsync_subscribe(client, "SensorData",1, &opts)) != MQTTASYNC_SUCCESS)
    {
        printf("Failed to start subscribe, return code %d\n", rc);
        exit(-1);
    }
}

void  Server::onSubscribe(void* context, MQTTAsync_successData* response)
{
    printf("Subscribe succeeded\n");
    subscribed = 1;
}

void  Server::onSubscribeFailure(void* context, MQTTAsync_failureData* response)
{
    printf("Subscribe failed, rc %d\n", response ? response->code : 0);
    finished = 1;
}

#包括“Server.h”
服务器：：服务器（const char*manufacturerID）{
此->manufacturerID=manufacturerID；
MQTTAsync_connectOptions conn_opts=MQTTAsync_connectOptions_初始值设定项；
MQTTAsync_disconnectOptions disc_opts=MQTTAsync_disconnectOptions_初始值设定项；
MQTTAsync_message pubmsg=MQTTAsync_message_初始值设定项；
MQTTAsync_令牌；
int rc；
int-ch；
MQTTAsync_创建（&this->MQTTclient）tcp://127.0.0.1:1883，manufacturerID，MQTTCLIENT\u PERSISTENCE\u NONE，NULL）；
MQTTAsync_setCallbacks（this->MQTTclient，NULL，connectionLost，messageArrived，NULL）；
conn_opts.keepAliveInterval=20；
conn_opts.cleansession=1；
conn_opts.onSuccess=onConnect；
conn_opts.onFailure=onConnectFailure；
conn_opts.context=this->MQTTclient；
if（（rc=MQTTAsync_connect（this->MQTTclient，&conn_opts））！=MQTTAsync_SUCCESS）
{
printf（“启动连接失败，返回代码%d\n”，rc）；
出口（-1）；
}
}
int-Server:：messageArrived（void*context，char*topicName，int-topicLen，MQTTAsync_message*message）
{
int i；
char*payloadptr；
printf（“消息到达\n”）；
printf（“主题：%s\n”，主题名）；
printf（“消息：”）；
payloadptr=（char*）消息->有效载荷；
对于（i=0；ipayloadlen；i++）
{
putchar（*payloadptr++）；
}
putchar（'\n'）；
MQTTAsync_freeMessage（&message）；
MQTTAsync_free（主题名称）；
返回1；
}
void服务器：：connectionLost（void*上下文，char*原因）
{
MQTTAsync客户端=（MQTTAsync）上下文；
MQTTAsync_connectOptions conn_opts=MQTTAsync_connectOptions_初始值设定项；
int rc；
printf（“\n连接丢失\n”）；
printf（“原因：%s\n”，原因）；
printf（“重新连接”）；
conn_opts.keepAliveInterval=20；
conn_opts.cleansession=1；
if（（rc=MQTTAsync\u连接（客户端和连接选项））！=MQTTAsync\u成功）
{
printf（“启动连接失败，返回代码%d\n”，rc）；
完成=1；
返回；
}
}
void服务器：：OnConnectionFailure（void*上下文，MQTTAsync\u failureData*响应）
{
printf（“连接失败，rc%d\n”，响应？响应->代码：0）；
完成=1；
}
void服务器：：onConnect（void*上下文，MQTTAsync_successData*响应）
{
MQTTAsync客户端=（MQTTAsync）上下文；
MQTTAsync_responseOptions opts=MQTTAsync_responseOptions_初始值设定项；
MQTTAsync_message pubmsg=MQTTAsync_message_初始值设定项；
int rc；
printf（“成功连接”）；
printf（“使用QoS%d订阅客户端%s的主题%s\n\n”
“按Q退出\n\n”，“传感器数据”，此->manufacturerID，1）；
opts.onSuccess=onSubscribe；
opts.onFailure=onSubscribeFailure；
opts.context=客户端；
deliveredtoken=0；
if（（rc=MQTTAsync_subscribe（客户端，“传感器数据”，1，&opts））！=MQTTAsync_SUCCESS）
{
printf（“启动订阅失败，返回代码%d\n”，rc）；
出口（-1）；
}
}
void服务器：：onSubscribe（void*上下文，MQTTAsync_successData*响应）
{
printf（“订阅成功\n”）；
认购=1；
}
void服务器：：onSubscribeFailure（void*上下文，MQTTAsync\u failureData*响应）
{
printf（“订阅失败，rc%d\n”，响应？响应->代码：0）；
完成=1；
}

Server.h

#ifndef MANUFACTURER_SERVER_H
#define MANUFACTURER_SERVER_H


#include <string>
#include <MQTTAsync.h>

class Server {
public:

    explicit Server(const char *manufacturerName);

    int messageArrived(void *context, char *topicName, int topicLen, MQTTAsync_message *message);

    void connectionLost(void *context, char *cause);

    void onConnectFailure(void *context, MQTTAsync_failureData *response);

    void onConnect(void *context, MQTTAsync_successData *response);

    void onSubscribe(void *context, MQTTAsync_successData *response);

    void onSubscribeFailure(void *context, MQTTAsync_failureData *response);
private:
    volatile MQTTAsync_token deliveredtoken;
    MQTTAsync MQTTclient;
    std::string manufacturerID;
    int finished = 0;
    int subscribed = 0;

};


#endif //MANUFACTURER_SERVER_H

\ifndef制造商\u服务器\u H
#定义制造商\u服务器\u H
#包括
#包括
类服务器{
公众：
显式服务器（const char*manufacturerName）；
int messageArrived（void*context、char*topicName、int-topicLen、MQTTAsync_message*message）；
void connectionLost（void*上下文，char*原因）；
void onConnectFailure（void*上下文，MQTTAsync_failureData*响应）；
void onConnect（void*上下文，MQTTAsync_successData*响应）；
void onSubscribe（void*上下文，MQTTAsync_successData*响应）；
订阅无效（无效*上下文，MQTTAsync_failureData*响应）；
私人：
易失性MQTTAsync_令牌deliveredtoken；
MQTTAsync MQTTclient；
std：：字符串制造商RID；
int=0；
int=0；
};
#endif//MANUFACTURER\u SERVER\u H

参考文献，这些是C++和C:

的PAHO MQTT库

---

事件应该是指向静态函数的指针，而不是类的方法

应使用上下文存储指向类服务器实例的指针：

MQTTAsync_setCallbacks(this->MQTTclient, this, connectionLost, messageArrived, NULL);

定义静态存根以将回调转发到实例：

static void onConnect(void *context, MQTTAsync_successData *response) {
    static_cast<Server*>(context)->onConnect(response);
}

可能重复的

conn_opts.onSuccess = &Server::onConnect;