C++ 11: ¿En qué orden se destruyen las capturas lambda?

Question

Digamos que tengo dos punteros inteligentes locales, foo y bar.

shared_ptr<Foo> foo = ... 
shared_ptr<Bar> bar = ... 

Estos punteros inteligentes son envolturas alrededor de los recursos que por alguna razón debe ser dañoso para el orden foo, a continuación, bar.

Ahora quiero crear una lambda que use foo y bar, pero sobrevive al ámbito que las contiene. Así que me gustaría capturarlos por valor, de esta manera:

auto lambda = [foo, bar]() { ... }; 

Esto crea copias de foo y bar dentro del objeto de función. Cuando se destruye el objeto de función, estas copias también se destruirán, pero me importa el orden en que esto sucede. Entonces mi pregunta es:

Cuando se destruye un objeto lambda, ¿en qué orden se destruyen sus capturas de valor por defecto? ¿Y cómo puedo (con suerte) influir en esta orden?

Answer 1

La especificación cubre esto ... más o menos. Desde 5.1.2, párrafo 14:

Una entidad es capturado por copia si es capturado de forma implícita y la captura predeterminado es = o si se captura de forma explícita con una captura que no incluye un &. Para cada entidad capturada por copia, se declara un miembro de datos no estáticos no identificado en el tipo de cierre. El orden de declaración de estos miembros no está especificado.

Énfasis añadido. Como la orden de declaración no está especificada, la orden de construcción no está especificada (ya que el orden de construcción es el mismo que el orden de la declaración). Y por lo tanto, el orden de destrucción no está especificado, ya que el orden de destrucción es el inverso al orden de construcción.

En resumen, si necesita preocuparse por el orden de la declaración (y las diversas órdenes de destrucción/construcción que salen de ella), usted no puede usar una lambda. Tendrás que hacer tu propio tipo.

Answer 2

De acuerdo con el documento de C++ 11 que tengo (es decir, el obsequio, ligeramente anterior a la ratificación n3242), sección 5.1.2, párrafo 21, las capturas se construyen en orden de declaración y se destruyen en orden de declaración inversa . Sin embargo, el orden de la declaración no está especificado (párrafo 14). Entonces, la respuesta es "en un orden no especificado" y "no se puede influir" (excepto, supongo, escribiendo un compilador).

Si la barra realmente necesita ser destruida antes de foo, sería aconsejable que la barra mantenga un puntero compartido a foo (o algo por el estilo).

Answer 3

En lugar de preocuparse por el orden de destrucción, debe solucionar el hecho de que esto es un problema. Al observar que está utilizando punteros compartidos para ambos objetos, puede garantizar el orden de destrucción agregando un puntero compartido en el objeto que necesita para sobrevivir al otro. En ese punto si foo o bar se destruye antes no importará. Si el orden es correcto, la destrucción del puntero compartido liberará los objetos inmediatamente. Si el orden es incorrecto, el puntero compartido adicional mantendrá el objeto vivo hasta que el otro desaparezca.

Answer 4

Como dice Nicol, el orden de destrucción no está especificado.

Sin embargo, no deberías tener que depender de la destrucción de la lambda. Debería poder simplemente restablecer foo al final de su lambda, garantizando así que libera su recurso antes de que bar lo haga. También deberá marcar la lambda como mutable. El único inconveniente aquí es que no puedes llamar al lambda varias veces y esperar que funcione.

auto lambda = [foo, bar]() mutable { ...; foo.reset(); }; 

---

Si necesita su lambda ser exigibles varias veces, entonces usted necesita para llegar a alguna otra forma de controlar el orden de cancelación de asignación. Una opción sería utilizar una estructura intermedia con una orden de miembro de datos conocidos, tales como std::pair<>:

auto p = std::make_pair(bar, foo); 
auto lambda = [p]() { auto foo = p.second, bar = p.first; ... };