C++ 返回类型为的回调函数

方法“DataOperation”必须返回DataResponse类型中的值

我在异步请求应答“LoadDataReply”中有一个回调函数，在该函数中，我对收到的应答应用了一些业务逻辑，并返回到main方法（我不确定返回回调是否正确）

你们能帮助我如何返回LoadData方法调用方的值吗

DataResponse DataOperation::LoadData(const RequestType request)
{
DataResponse dataResponse;
messageAssistant.AsyncRequest("LoadDataList", request)
    .OnReply<MyResponseType>("LoadDataListReply", [this, &dataResponse](auto& reply) { dataResponse = this->LoadDataFromResponse(reply); });

return dataResponse;
}

DataResponse DataOperation::LoadDataFromResponse(const MyResponseType& reply)
{
   ///Doing some operation with reply data
   DataResponse dataResponse;
   dataResponse.Data = reply.Data();
   return dataResponse;
}

注意：-我已经更新了代码，正在编译，没有任何问题。但我从LoadData返回的dataResponse对象在LoadDataFromResponse中没有更新值。它具有初始值

---

如何确保它返回更新的值而不是初始值？

使用处理程序。您可以创建处理程序（每个线程都可以访问的消息列表）。请看下面的pseodocode：

class Handler {
 public:
  Handler();
  // Constructor
  ~Handler();
  // Destructor
  void pushmessage ( DataResponse* p );
  DataResponse* popmessage();
  bool empty();
protected:
  vector<DataResponse*> pool;
  RTTICriticalSection CS;
};

Handler::Handler()
{
  CS = CreateCriticalSection;
}

Handler::~Handler()
{
  DeleteCriticalSection(CS);
}

void Handler::pushmessage ( DataResponse* p )
{
  EnterCriticalSection(CS);
  try {
    pool.push_back(p)
  } catch(...){
    //
  }
  LeaveCriticalSection(CS);
}

DataResponse* Handler::popmessage() {
  DataResponse* dr = null;
  EnterCriticalSection(CS);
  try {
    dr = pool.back();
    pool.pop_back();
  } catch(...){
    //
  }
  LeaveCriticalSection(CS);    
  return dr;
}

bool Handler::empty() {
  bool res = true;
  EnterCriticalSection(CS);
  try {
    res = pool.empty();
  } catch(...){
    //
  }
  LeaveCriticalSection(CS);    
  return res;      
}

DataResponse DataOperation::LoadData(const RequestType request)
{
   messageAssistant.AsyncRequest("LoadDataList", request)
    .OnReply<MyResponseType>("LoadDataListReply", [this](auto& reply) {  this->LoadDataFromResponse(reply); });  
}

/*DataResponse* */ void DataOperation::LoadDataFromResponse(const MyResponseType& reply)
{
   ///Doing some operation with reply data
   DataResponse* dataResponse = new DataResponse();
   dataResponse.Data = reply.Data();
   handler.pushmessage( dataResponse );
   //return dataResponse;
}

//call this sub somewhere inside the idle cycle synchronized with the main thread
void proceedMessages() {
  while (!handler.empty())
  {
    DataResponse* dr = handler.popmessage();
    //do something with dr
    //free dr
  }
}

类处理程序{
公众：
Handler（）；
//建造师
~Handler（）；
//析构函数
无效推送消息（数据响应*p）；
DataResponse*popmessage（）；
bool empty（）；
受保护的：
向量池；
RTC临界截面；
};
Handler:：Handler（）
{
CS=创建临界截面；
}
处理程序：：~Handler（）
{
删除临界截面（CS）；
}
void处理程序：：pushmessage（DataResponse*p）
{
肠危重科；
试一试{
池。推回（p）
}捕获（…）{
//
}
离境管制组（CS）；
}
DataResponse*处理程序：：popmessage（）{
DataResponse*dr=null；
肠危重科；
试一试{
dr=pool.back（）；
pool.pop_back（）；
}捕获（…）{
//
}
离境管制组（CS）；
返回dr；
}
bool处理程序：：empty（）{
bool res=真；
肠危重科；
试一试{
res=pool.empty（）；
}捕获（…）{
//
}
离境管制组（CS）；
返回res；
}
DataResponse DataOperation:：LoadData（常量请求类型请求）
{
异步请求（“LoadDataList”，请求）
.OnReply（“LoadDataListReply”，[this]（自动和回复）{this->LoadDataFromResponse（回复）；}）；
}
/*DataResponse**/void DataOperation:：LoadDataFromResponse（常量MyResponseType&reply）
{
///使用回复数据执行一些操作
DataResponse*DataResponse=新的DataResponse（）；
dataResponse.Data=reply.Data（）；
handler.pushmessage（dataResponse）；
//返回数据响应；
}
//在与主线程同步的空闲周期内的某个地方调用此子线程
void proceedMessages（）{
而（！handler.empty（））
{
DataResponse*dr=handler.popmessage（）；
//和dr
//免费dr
}
}

这已通过使用回调修复。

您没有返回任何值吗？我需要将dataResponse返回给LoadData方法的调用方。@Joe所以，

返回它
LoadData
是非void函数，但它没有
return
语句，这反过来意味着此类程序的行为未定义。我建议增加LoadData以接受另一个类型为
DataResponse&
的参数，然后更改
LoadData
以返回
void
。然后，传递给
.OnReply
的lambda还应捕获
数据响应&
，并将其设置为等于
此->LoadDataFromResponse
的结果
class Handler {
 public:
  Handler();
  // Constructor
  ~Handler();
  // Destructor
  void pushmessage ( DataResponse* p );
  DataResponse* popmessage();
  bool empty();
protected:
  vector<DataResponse*> pool;
  RTTICriticalSection CS;
};

Handler::Handler()
{
  CS = CreateCriticalSection;
}

Handler::~Handler()
{
  DeleteCriticalSection(CS);
}

void Handler::pushmessage ( DataResponse* p )
{
  EnterCriticalSection(CS);
  try {
    pool.push_back(p)
  } catch(...){
    //
  }
  LeaveCriticalSection(CS);
}

DataResponse* Handler::popmessage() {
  DataResponse* dr = null;
  EnterCriticalSection(CS);
  try {
    dr = pool.back();
    pool.pop_back();
  } catch(...){
    //
  }
  LeaveCriticalSection(CS);    
  return dr;
}

bool Handler::empty() {
  bool res = true;
  EnterCriticalSection(CS);
  try {
    res = pool.empty();
  } catch(...){
    //
  }
  LeaveCriticalSection(CS);    
  return res;      
}

DataResponse DataOperation::LoadData(const RequestType request)
{
   messageAssistant.AsyncRequest("LoadDataList", request)
    .OnReply<MyResponseType>("LoadDataListReply", [this](auto& reply) {  this->LoadDataFromResponse(reply); });  
}

/*DataResponse* */ void DataOperation::LoadDataFromResponse(const MyResponseType& reply)
{
   ///Doing some operation with reply data
   DataResponse* dataResponse = new DataResponse();
   dataResponse.Data = reply.Data();
   handler.pushmessage( dataResponse );
   //return dataResponse;
}

//call this sub somewhere inside the idle cycle synchronized with the main thread
void proceedMessages() {
  while (!handler.empty())
  {
    DataResponse* dr = handler.popmessage();
    //do something with dr
    //free dr
  }
}