c++ - smart - Diferencia entre capturar y pasar un argumento en funciones lambda

smart contracts ethereum

Question

Entiendo la función lambda y su propósito en c ++ 11. Pero no entiendo la diferencia entre "Capturar el valor" y "Pasar un argumento". Por ejemplo..

#include <iostream>
#include <functional>
using namespace std;
int add(int a,int b){
return a+b;
}
int main(int argc, char** argv){
function <int(int,int)> cppstyle;
cppstyle = add;
auto l = [] (function <int(int,int)> f,int a, int b) {return f(a,b);};
cout << l(cppstyle,10,30) <<"/n";
}

La salida del código anterior es la misma que la del código siguiente.

#include <iostream>
#include <functional>
using namespace std;
int add(int a,int b){
return a+b;
}
int main(int argc, char** argv){
function <int(int,int)> cppstyle;
cppstyle = add;
auto l = [cppstyle] (int a, int b) {return cppstyle(a,b);};
cout << l(10,30) <<"/n";
}

¿Es "capturar un valor" similar a "pasar un valor como un argumento"? ¿O la captura tiene algún significado especial?

Answer 1

En un nivel más alto, captura los datos que conoce ahora y pasa los datos que no tiene hasta que necesita hacer la llamada.

Por ejemplo, supongamos que desea agregar una constante a cada número en un vector. Podrías escribirlo como (precaución: no probado):

void Add(std::vector<int>& v, int i)
{
std::for_each(std::begin(v), std::end(v), [i](int& j){ j += i; });
}

Answer 2

La diferencia entre un argumento capturado y un argumento que pasa podría verse con una analogía. Considere el siguiente objeto de función:

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;
}
};

En la clase de objeto de función Capture hay dos variables miembro i y j . También hay un operator() sobrecargado operator() que toma dos argumentos de entrada. Ahora considera la siguiente lambda:

int i, j;
[&i, j](int const a, int const b) {
i *= j;
return a * b;
};

Las variables miembros de la clase Capture están en analogía con la captura lambda (es decir, [&i, j] ), mientras que los argumentos de entrada del operator() sobrecargado operator() a y b son en analogía con los argumentos de entrada a y b del lambda que se muestra arriba.

Es decir, si considera un lambda como un objeto de función, su captura es el estado del objeto de función (es decir, sus variables miembro), mientras que sus argumentos de entrada serían los argumentos de entrada del operator() sobrecargado operator() .