The difference between a captured argument and a passing argument could be seen with an analogy. Consider the following function object:

`struct Capture {`

int &i;

int const j;

public:

Capture(int &_i, int &_j) : i(_i), j(_j) {}

int operator()(int const a, int const b) {

i *= j;

return a * b;

}

};

In function object class `Capture`

there are two member variables `i`

and `j`

. There's also overloaded `operator()`

which takes two input arguments. Now consider the following lambda:

`int i, j;`

[&i, j](int const a, int const b) {

i *= j;

return a * b;

};

The member variables of class `Capture`

are in analogy with the lambda capture (i.e., `[&i, j]`

), whereas input arguments of overloaded `operator()`

`a`

and `b`

are in analogy with input arguments `a`

and `b`

of the lambda shown above.

That is, if you consider a lambda as a function object, its capture is the state of the function object (i.e., its member variables) whereas its input arguments would be the input arguments of the overloaded `operator()`

.