lambda捕获成员变量由此

Question

To capture a member data in object, the lambda need capture 'this' pointer:

class A {
public:
    void func() {
       auto f = [this](){_b->do_something();};
       _c->run(f); // asynchronized method
    }
private:
    B* _b;
    C* _c;
};

There is a problem: when f gets called by _c, object of A may be destory! Will _b->do_something(); become an undefined behavior?

Answer 1

Make use of a shared_ptr , and then capture that in the lambda. Now when you create the instance of A you will need to do so with make_shared . It's best if you inherit from enable_shared_from_this and then you can use shared_from_this in the lambda capture to force the A to stay around for long enough for the lambda to run without needing to have a reference to the shared_ptr anywhere else.

The first part of your class will look something like this:

class A : std::enable_shared_from_this<A> {
public:
    void func() {
       auto self = shared_from_this();
       auto f = [this, self](){_b.do_something();};
       _c->run(f); // asynchronized method
    }

Answer 2

From 3.8 Object life

5. [...] after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that refers to the storage location where the object will be or was located may be used but only in limited ways. [...] The program has undefined behavior if:

[...]

5.2 the pointer is used to access a non-static data member or call a non-static member function of the object

So yes, using pointer to B in destroyed A is UB.