How Can I Safely Capture a Unique Pointer in a C Lambda Expression?

Capturing a Unique Ptr into a Lambda Expression in C

In C , when dealing with unique pointers and lambdas, capturing ownership can be challenging. One common attempt is to pass a std::unique_ptr by reference and capture it within a lambda:

std::function<void()> getAction(std::unique_ptr<MyClass>& psomething);

return [psomething]() { psomething->do_some_thing(); };

However, this approach fails to compile due to lifetime issues. To address this, C 14 introduced lambda generalized capture, which allows for explicitly specifying ownership transfer:

std::function<void()> getAction(std::unique_ptr<MyClass> psomething) {
    return [auto psomething = move(psomething)]() { psomething->do_some_thing(); };
}

By using auto psomething = move(psomething), ownership of the unique pointer is transferred to the lambda, eliminating lifetime concerns.

However, if you have custom move and copy implementations as shown below:

template<typename T>
T copy(const T &amp;t) {
    return t;
}

template<typename T>
T move(T &amp;t) {
    return std::move(t);
}

You should be careful when using move for lvalue references as it can lead to undefined behavior. For example, moving a temporary object using move(A()) should be avoided. Instead, it's recommended to provide separate move and copy versions for lvalue and rvalue references.

Therefore, when capturing a unique pointer into a lambda expression, lambda generalized capture provides a convenient and explicit way to handle ownership transfer, ensuring proper lifetime management.

The above is the detailed content of How Can I Safely Capture a Unique Pointer in a C Lambda Expression?. For more information, please follow other related articles on the PHP Chinese website!