Come può un valore unique_ptr essere restituito dal valore senza std :: move?

Question

std::unique_ptr<int> ptr() { 
    std::unique_ptr<int> p(new int(3)); 
    return p; // Why doesn't this require explicit move using std::move? 
} // Why didn't the data pointed to by 'p' is not destroyed here though p is not moved? 

int main() { 
    std::unique_ptr<int> a = ptr(); // Why doesn't this require std::move? 
    std::cout << *a; // Prints 3. 
} 

Nel codice precedente, la funzione ptr() restituisce una copia di p. Quando lo p esce dal campo di applicazione, i dati "3" dovrebbero essere eliminati. Ma come funziona il codice senza alcuna violazione di accesso?

Answer 1

Ciò è definito nello standard C++ 11, § 12,8/32:

Quando i criteri di elisione un'operazione di copia sono soddisfatte o sarebbero soddisfatte risparmi per il fatto che l'oggetto di origine sia un parametro di funzione, e l'oggetto da copiare sia designato da un lvalue, la risoluzione di sovraccarico per selezionare il costruttore per la copia viene eseguita per la prima volta come se l'oggetto fosse designato da un valore ....

(sottolineatura mia). In italiano semplice, significa che il lvalue p può essere considerato come un rvalue quando si tratta di risoluzione di sovraccarico, perché è un candidato per copia elision. Ciò a sua volta significa che il costruttore di movimento viene rilevato in risoluzione di sovraccarico (in realtà, la copia di spostamento viene probabilmente eliminata in ogni caso)

Answer 2

Poiché return di certe espressioni quali variabili automatiche locali, sono esplicitamente definite per restituire un spostato oggetto, se l'operatore è possibile il trasferimento.

Quindi:

return p; 

è più o meno simile a:

return std::move(p); 

Ma si noti che questo non funzionerà, per esempio con una variabile globale.

std::unique_ptr<int> g(new int(3)); 
std::unique_ptr<int> ptr() { 
    return g; // error!!! 
}