CKTIS / C++
Copy elision, NRVO e move implicito
Distingui la costruzione garantita da un prvalue, la NRVO facoltativa e il move implicito in C++23. Restituire per valore non comporta necessariamente una copia, ma la correttezza del programma non deve dipendere dall’applicazione della NRVO.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
T direct() { return T{}; }
T named() { T local; return local; }
T forward_value(T value) { return value; }La copy elision consente, in determinate circostanze, di omettere una costruzione per copia o per move, anche se ciò modifica gli effetti osservabili di costruttori e distruttori. Non basare la logica del programma sul numero di queste chiamate.
La copy elision garantita è il nome comune delle regole sui prvalue in vigore da C++17. In T direct() { return T{}; }, il risultato viene costruito direttamente nell’oggetto di destinazione dello stesso tipo, ignorando i qualificatori cv nel confronto dei tipi. Non si tratta di NRVO facoltativa: non è necessario un costruttore di copia o di move, ma il distruttore deve essere accessibile e non eliminato.
La NRVO (named return value optimization) può applicarsi a return local; quando local è un oggetto automatico non volatile del tipo appropriato, non un parametro di funzione né una variabile del gestore di eccezioni. In C++23 la NRVO resta facoltativa; i requisiti relativi al costruttore selezionato continuano ad applicarsi. Scrivere return std::move(local); non soddisfa il requisito della NRVO secondo cui l’espressione deve nominare l’oggetto.
Il move implicito non omette la costruzione. In C++23, un’espressione idonea al move viene trattata come xvalue; questo include i casi tipici di restituzione di oggetti locali o parametri passati per valore. La risoluzione degli overload può selezionare un costruttore di move oppure una copia disponibile che accetta const T&; se il costruttore di move selezionato è eliminato, si verifica un errore invece di ritentare con la copia. forward_value mostra un parametro: non è incluso nella NRVO, ma supporta il move implicito. Questa voce descrive C++23; le pagine citate sono una bozza in evoluzione, non un’edizione C++23 definitiva.
Identificatori di riferimento trattati in questa voce: Copy elision, NRVO and implicit move.
Esempi
#include <iostream>
struct T {
int value;
explicit T(int n = 0) : value(n) {}
T(const T&) = delete;
T(T&&) = default;
};
T direct() {
return T{10};
}
T named() {
T local{20};
return local;
}
T forward_value(T value) {
return value;
}
int main() {
T a = direct();
T b = named();
T c = forward_value(T{30});
std::cout << a.value << ' ' << b.value << ' ' << c.value << '\n';
}
Risultato
10 20 30
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.