¿Se garantiza que el destructor de un objeto local dentro de un bucle se invocará antes de la próxima iteración?

Cuando tengo un bucle y dentro de este bucle, creo una nueva variable de pila (sin asignarla en el montón y la variable que la mantiene declarada dentro del cuerpo del bucle), ¿se garantiza que se llamará al destructor de este objeto antes de que comience la próxima iteración, o podría ¿Desenrollar el bucle por el compilador cambia algo al respecto?

De n4800:

§6.3.3 Alcance del bloque :

Un nombre declarado en un bloque (8.3) es local para ese bloque; Tiene alcance de bloque. Su alcance potencial comienza en su punto de declaración (6.3.2) y termina al final de su bloque. Una variable declarada en el alcance del bloque es una variable local.

§10.3.6 Destructores :

Un destructor se invoca implícitamente [...] cuando el bloque en el que se crea un objeto sale (8.7)

§4.1.1 Máquina abstracta :

Esta disposición a veces se llama la regla "como si", porque una implementación es libre de ignorar cualquier requisito de este documento siempre que el resultado sea como si el requisito hubiera sido obedecido, en la medida en que pueda determinarse a partir del comportamiento observable de El programa .

[El énfasis es mío]

Entonces sí. Su variable queda fuera de alcance al final del ciclo (que es un bloque) y, por lo tanto, se llama a su destructor por lo que cualquiera que observe el comportamiento del programa puede ver .

Si. Es más fácil visualizar cuando considera los "bloques" en los que declara una variable, es decir, entre qué par de llaves. El ciclo es un bloque en sí mismo, y cuando alcanza el paréntesis de cierre, antes de la siguiente iteración, se llama a todos los destructores de variables de almacenamiento automático declaradas en el ciclo.

¿podría el bucle desenrollar por el compilador cambiar algo al respecto?

Como regla general, no piense en lo que optimizará el compilador, porque aún necesita garantizar el comportamiento de su programa, sin importar lo que haga para optimizarlo. En ese caso, el desenrollado de bucle no cambiará nada a ese efecto si sucede.

Se llama al destructor para cada iteración. Por lo tanto, en algunos casos es más rápido declarar una variable fuera del ciclo en lugar de hacerlo en el ciclo. Suponiendo el siguiente caso:

std::string temp;
for(int i = 0; i < 10; ++i){
    temp = arr[i];
    doSomething(temp);
}

No se llama al destructor cuando se ejecuta el uso del bucle. Simplemente anula temp.

Pero si usa std::string temp = arr[i]el constructor y se llama al destructor para cada iteración. Creo que esto agrega un poco de tiempo de ejecución en caso de que tenga un bucle que se ejecuta con mucha frecuencia.

Se llama al destructor antes de la siguiente iteración

Por supuesto, se llama a dtor al final de la iteración y el desenrollado del bucle no debería modificar este comportamiento, como cualquier otra optimización (una optimización no debería modificar el comportamiento del programa), excepto algún tipo de RVO y similares que pueden eliminar algunas creaciones de objetos semánticamente espurios .