Il distruttore di un oggetto locale all'interno di un loop è garantito per essere chiamato prima della successiva iterazione?

Quando ho un loop e all'interno di questo loop creo una nuova variabile di stack (non allocandola sull'heap e tenendo la variabile dichiarata all'interno del corpo del loop), il distruttore di questo oggetto è garantito per essere chiamato prima dell'inizio della successiva iterazione, o potrebbe lo srotolamento del loop da parte del compilatore cambia qualcosa al riguardo?

Da n4800:

§6.3.3 Ambito di applicazione del blocco :

Un nome dichiarato in un blocco (8.3) è locale per quel blocco; ha un ambito di blocco. La sua portata potenziale inizia nel punto di dichiarazione (6.3.2) e termina alla fine del blocco. Una variabile dichiarata nell'ambito del blocco è una variabile locale.

§10.3.6 Distruttori :

Un distruttore viene invocato implicitamente [...] quando esce il blocco in cui viene creato un oggetto (8.7)

§4.1.1 Macchina astratta :

Questa disposizione è talvolta chiamata regola "come se", poiché un'implementazione è libera di ignorare qualsiasi requisito del presente documento purché il risultato sia come se il requisito fosse stato rispettato, per quanto si può determinare dal comportamento osservabile di il programma .

[Enfasi mia]

Quindi sì. La tua variabile esce dall'ambito alla fine del loop (che è un blocco) e quindi il suo distruttore viene chiamato per quanto chiunque può osservare il comportamento del programma .

Sì. È più facile da visualizzare se si considerano i "blocchi" in cui si dichiara una variabile, ovvero tra quale coppia di parentesi graffe. Il loop è di per sé un blocco e quando raggiunge la parentesi di chiusura, prima della successiva iterazione, vengono chiamati tutti i distruttori delle variabili di memorizzazione automatiche dichiarate nel loop.

lo srotolamento del compilatore potrebbe cambiare qualcosa al riguardo?

Come regola generale non pensare a ciò che il compilatore ottimizzerà, perché deve comunque garantire il comportamento del tuo programma, indipendentemente da ciò che fa per ottimizzarlo. In tal caso, lo srotolamento del loop non cambierà nulla in tal senso se ciò dovesse accadere.

Il distruttore è chiamato per ogni iterazione. Pertanto, in alcuni casi è più veloce dichiarare una variabile all'esterno del ciclo anziché nel ciclo. Supponendo il seguente caso:

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

Il distruttore non viene chiamato quando viene eseguito l'utilizzo del loop. Sostituisce e basta temp.

Ma se si utilizza std::string temp = arr[i]il costruttore e viene chiamato il distruttore per ogni iterazione. Penso che questo aggiunga un po 'di runtime nel caso in cui tu abbia un loop che viene eseguito molto spesso.

Il distruttore viene chiamato prima della successiva iterazione

Naturalmente dtor viene chiamato alla fine dell'iterazione e lo svolgimento di loop non dovrebbe modificare questo comportamento, come qualsiasi altra ottimizzazione (un'ottimizzazione non dovrebbe modificare il comportamento del programma), tranne qualche tipo di RVO e simili che possono eliminare alcune creazioni di oggetti semanticamente spurie .