Why capturing lambda does not capture variables? [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 4 years ago.
Improve this question
I don't understand why the callback lambda passed to c_style_callback does not access to the correct values of callback and key. How to get these 2 to be available from the lambda?
I tried with explicit copy [callback=callback, key=key], didn't help.
This is a C++ wrapper implementation of a C method called subscribe.
I think the following code covers my issue, let me know if anything else needed.
Wrapper, the issue is located here. Please check the comments at the end of the lines:
std::function<void()> AWS::subscribe(const std::string &topic, std::function<void(const std::string&)> callback, QoS qos) {
ESP_LOGI(TAG, "subscribe: %s", topic.c_str());
std::string key("Test...");
auto task = c_style_callback(
[=] (AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen, IoT_Publish_Message_Params *params) {
std::string json;
json.assign((char *)params->payload, (size_t)params->payloadLen);
ESP_LOGI(TAG, "subscribe cb payload=%s", json.c_str()); // works
ESP_LOGI(TAG, "key '%s'", key.c_str()); // undefined behaviour
callback(json);// error, exit
}
);
m_error = ::aws_iot_mqtt_subscribe(
&m_client,
key.c_str(),
key.length(),
qos,
task.get_callback<AWS_IoT_Client*, char*, uint16_t, IoT_Publish_Message_Params*>(),
task.get_pvoid()
);
if (m_error != SUCCESS) {
ESP_LOGD(TAG, "subscribe: error=%d", m_error);
return nullptr;
}
return [=] () {
ESP_LOGI(TAG, "unsubscribe %s", key.c_str()); // works
callback(key); // works
};
} // subscribe
c_style_callback utility function:
template<class F>
struct c_style_callback_t {
F f;
template<class...Args>
static void(*get_callback())(Args..., void*) {
return [](Args...args, void* fptr)->void {
(*static_cast<F*>(fptr))(std::forward<Args>(args)...);
};
}
void* get_pvoid() {
return std::addressof(f);
}
};
template<class F>
c_style_callback_t< std::decay_t<F> >
c_style_callback( F&& f ) { return {std::forward<F>(f)}; }
Main task where the subscribe wrapper is being called - this is only for giving context to the example, how I try to use the C++ wrapper of subscribe:
{
...
aws->subscribe(
topic,
[] (const std::string &json) -> void {
ESP_LOGI(TAG, "got json: %s", json.c_str());
}
);
...
}
Update:
More about aws_iot_mqtt_subscribe:
/**
* #brief Subscribe to an MQTT topic.
*
* Called to send a subscribe message to the broker requesting a subscription
* to an MQTT topic.
* #note Call is blocking. The call returns after the receipt of the SUBACK control packet.
*
* #param pClient Reference to the IoT Client
* #param pTopicName Topic Name to publish to
* #param topicNameLen Length of the topic name
* #param pApplicationHandler_t Reference to the handler function for this subscription
* #param pApplicationHandlerData Data to be passed as argument to the application handler callback
*
* #return An IoT Error Type defining successful/failed subscription
*/
IoT_Error_t aws_iot_mqtt_subscribe(AWS_IoT_Client *pClient, const char *pTopicName, uint16_t topicNameLen,
QoS qos, pApplicationHandler_t pApplicationHandler, void *pApplicationHandlerData);

Answer 1

I assume aws_iot_mqtt_subscribe stores its arguments for latter reference - to call, in response to some event at some later point in time, the function passed as its next-to-last argument, with the pointer passed as its last argument.
The pointer obtained with task.get_pvoid() points to a data member of task. In turn, task is a local variable - it's destroyed when subscribe returns, together with its data member, whereupon that pointer becomes dangling.
Later, the function manufactured by c_style_callback_t::get_callback receives that no-longer-valid pointer and attempts to dereference it. Thereby the program exhibits undefined behavior, by way of accessing an object after its lifetime has ended.