Lambda capturing this and long-running function - c++

Question

I have a function that takes a long time to run, but thankfully it runs asynchronously. I want to take the result of this function call and set it to a class instance's private variable. Seems easy:
// Exists in some other library.
void LongRunningAsync(std::function<void(int)> callback) {
sleep(10);
callback(5);
}
class A {
public:
void Do() {
auto lambda = [this](int val) {
// Some processing...
var_ = val;
};
LongRunningAsync(lambda);
}
private:
var_;
};
int main() {
A* a = new A;
a->Do();
// Wait for LongRunningAsync to finish.
sleep(20);
return 0;
}
The problem is adding the following line to main, right before the comment:
delete a;
Now when LongRunningAsync invokes the callback, it will attempt to modify a member variable of a deleted instance (which is UB).
Is there a way to salvage this approach? I've recently learned about the following solution:
void LongRunningAsync(std::function<void(int)> callback) {
sleep(10);
callback(5);
}
class A : public std::enable_shared_from_this<A> {
public:
void Do() {
std::weak_ptr<A> weak = shared_from_this();
auto lambda = [weak](int val) {
auto shared = weak.lock();
if (!shared) return;
// Some processing...
shared->var_ = val;
};
LongRunningAsync(lambda);
}
private:
var_;
};
int main() {
auto a = std::make_shared<A>();
a->Do();
// Wait for LongRunningAsync to finish.
sleep(20);
return 0;
}
But it requires changing all A variables to shared_ptr. Is there a less intrusive way to make this work?

Answer 1

One possible solution is to just encapsulate the state you need into a shared_ptr member variable and then capture that by value into the closure that runs asynchronously.
Something like the following
class A : public std::enable_shared_from_this<A> {
public:
void Do() {
auto lambda = [member_shared_state](int val) {
member_shared_state->var_ = val;
};
LongRunningAsync(lambda);
}
....
};

Answer 2

Here's a solution based on Curious's approach, but that doesn't force me to change all pointers to A objects to shared_ptr:
// Exists in some other library.
void LongRunningAsync(std::function<void(int)> callback) {
sleep(10);
callback(5);
}
class A {
public:
A() : var_(std::make_shared<int>()) {}
void Do() {
std::weak_ptr<int> weak = var_;
auto lambda = [weak](int val) {
auto shared = weak.lock();
if (!shared) {
return;
}
// Some processing...
*shared = val;
};
LongRunningAsync(lambda);
}
private:
std::shared_ptr<int> var_;
};
int main() {
A* a = new A;
a->Do();
delete a;
// Wait for LongRunningAsync to finish.
sleep(20);
return 0;
}