When you are using lambdas in a member function, you can capture this implicitly through [=] or [&] or
explicitly through [this]. It will capture the current object pointer by reference or value, but the underlying object will always
be captured by reference (see S5019).
This will become a problem:
- When the lifetime of the lambda exceeds the one of the current object.
- When you want to capture the current state of the object.
- When you want to pass a copy of the object to avoid any concurrency issue.
C++14 provides a solution to this problem. You can copy the underlying object by using the following pattern:
auto lam = [copyOfThis = *this] { std::cout << copyOfThis.field; };
This is verbose and error-prone, as you might implicitly not use the copied object:
auto lam = [& , copyOfThis = *this] {
std::cout << field; // implicitly calling “this” captured by reference
};
C++17 solves this problem by introducing an explicit, consistent way to capture this by copy:
auto lam = [&, *this] {
std::cout << field // implicitly calling “this” captured by copy
};
This rule will flag the C++14 way of capturing the current object by copy and suggest replacing it with the C++17 way.
Noncompliant code example
struct A {
int field = 0;
void memfn() const {
auto lam = [copyOfThis = *this] { // Noncompliant
std::cout << copyOfThis.field;
};
}
};
Compliant solution
struct A {
int field = 0;
void memfn() const {
auto lam = [*this] { // Compliant
std::cout << field;
};
}
};
