variable de miembro de captura por valor

Question

¿Cómo puedo capturar una variable miembro por valor cuando uso C++ 11 expresiones lambda?

El uso de la sintaxis [my_member] no parece funcionar, y la captura implícita utiliza el puntero this. Lo que se necesita es una forma de especificar explícitamente el tipo de captura de las variables miembro. ¿Es eso posible?

Mi solución por ahora es:

void member_function() 
{ 
    std::shared_ptr<my_member_class> my_member_copy = my_member; // this shouldn't be necessary 
    std::async([=]{ std::cout << *my_member_copy; }); 
    // std::async([=]{ std::cout << *my_member_; }); // wrong, my member could be potentially out of scope 
} 

Answer 1

no creo que pueda capturar un miembro de valor, puede capturar this pero dado que el elemento es parte de this que va a utilizar una miembro compartido y no una nueva variable.

no saber lo que escriba su miembro es algo como esto debería funcionar:

auto copy = my_member; 
std::async([copy]{ std::cout << copy; }); 

No entiendo por qué estás usando un shared_ptr en su ejemplo, si se desea capturar por valor seguramente es shared_ptr lo último que debes considerar

Answer 2

En este momento, se enfrentan el mismo problema y lo resolvió a mí mismo:

1. captura el puntero this.
2. luego escribir this->member sintaxis dentro de la lambda:

Es decir,

std::async([this]{ std::cout << this->my_member_; }); 
//   ^^^^    ^^^^^^ use this syntax 
//   | 
//   ^
//   capture `this` as well 

Funciona para mí. Espero que te funcione también. Sin embargo, no estoy completamente satisfecho con este conocimiento. Después de mi trabajo, buscaré la razón por la cual se requiere esta sintaxis, o es un error del compilador. Estoy usando GCC 4.5.0 (MinGW).

Bueno, encontré el siguiente tema que dice this puntero se debe capturar para utilizar el miembro de la clase.

• Capturing this required to access member functions?

Answer 3

Por desgracia, no creo que hay una manera recta hacia adelante para hacer esto, pero puedo pensar en un par de maneras de capturar un miembro sin hacer una copia extra.

La primera opción es similar a su ejemplo, pero utiliza una referencia para la variable local:

void member_function() 
{ 
    std::shared_ptr<my_member_class> &my_member_ref = my_member; 
    // Copied by the lambda capture 
    std::async([my_member_ref]{ std::cout << *my_member_ref; }); 
} 

Tenga en cuenta que hay un error en la pre 4.6.2 versiones de GCC que causan el valor no debe ser copiado . Ver Capturing reference variable by copy in C++0x lambda.

Un segundo enfoque sería el uso de bind para hacer la copia:

void member_function() 
{ 
    // Copied by std::bind 
    std::async(std::bind([](const shared_ptr<my_member_class>& my_member){ 
     std::cout << *my_member; }, my_member)); 
} 

En este ejemplo, se unen hará su propia copia de my_member, y esta copia a continuación, se pasa a la expresión lambda por referencia .

Answer 4

Debido a que su pregunta es acerca de C++ 11 esto no es realmente una respuesta, pero en C++ 14 se puede hacer de esta manera:

void member_function() 
{ 
    std::async([my_member=my_member]{ std::cout << *my_member; }); 
} 

Se hace lo mismo como su propio "de obra alrededor "(si my_member es un shared_ptr).

Answer 5

auto& copy = my_member; 
std::async([copy]{ std::cout << copy; }); 

automático & (arriba) también funciona y evita copiar dos veces. Aunque este enfoque es más sintaxis que pasar [esto], evita pasar al cierre una dependencia del objeto al que [este] apunta.