# V788\. Consider reviewing a captured variable in lambda expression\.

The analyzer detected a suspicious variable capture in a lambda expression\.

Consider a few examples of this diagnostic rule\.

Example 1:

```cpp
int x = 0;
auto f = [x] { };
....
x = 42;
f();
....
```

A variable whose exact value can be calculated at compile time is captured by value in a lambda function\. Inside that function, the variable will be referring to the value that it had at the moment when it was captured rather than at the moment when the function was invoked\. The variable should probably be captured by reference instead\.

```cpp
int x = 0;
auto f = [&x] { };
....
x = 42;
f();
....
```

Another possible explanation is that the code where the variable used to be assigned some value was removed during refactoring\.

```cpp
int x = 0;
if (condition) x = 42;
else x = 43;
auto f = [x] { };
```

If you need to capture a constant, a better solution would be to explicitly declare the variable's type as `const` or `constexpr`\.

```cpp
constexpr int x = 0;
auto f = [x] { };
```

Example 2:

```cpp
int x;
auto f = [x] { };
```

An uninitialized variable is captured by value\. Using it will lead to undefined behavior\. If the variable was meant to be initialized by the function invocation, then it should be captured by reference\.

```cpp
int x;
auto f = [&x] { x = 42; };
```