Restituisce unique_ptr dalle funzioni

unique_ptr<T>non consente la costruzione di copie, ma supporta la semantica di spostamento. Tuttavia, posso restituire a unique_ptr<T>da una funzione e assegnare il valore restituito a una variabile.

#include <iostream>
#include <memory>

using namespace std;

unique_ptr<int> foo()
{
  unique_ptr<int> p( new int(10) );

  return p;                   // 1
  //return move( p );         // 2
}

int main()
{
  unique_ptr<int> p = foo();

  cout << *p << endl;
  return 0;
}

Il codice sopra si compila e funziona come previsto. Quindi, come mai quella linea 1non invoca il costruttore di copie e provoca errori del compilatore? Se invece dovessi usare line 2avrebbe senso (usare anche line 2funziona, ma non è necessario farlo).

So che C ++ 0x consente questa eccezione unique_ptrpoiché il valore restituito è un oggetto temporaneo che verrà distrutto non appena la funzione uscirà, garantendo così l'unicità del puntatore restituito. Sono curioso di sapere come questo viene implementato, è inserito nel compilatore o c'è qualche altra clausola nella specifica del linguaggio che questo sfrutta?

c'è qualche altra clausola nella specifica del linguaggio che questo sfrutta?

Sì, vedere 12.8 §34 e §35:

Quando vengono soddisfatti determinati criteri, un'implementazione è autorizzata a omettere la costruzione di copia / spostamento di un oggetto di classe [...] Questa elisione delle operazioni di copia / spostamento, chiamata elisione di copia , è consentita [...] in una dichiarazione di ritorno in una funzione con un tipo restituito di classe, quando l'espressione è il nome di un oggetto automatico non volatile con lo stesso tipo non qualificato cv del tipo restituito di funzione [...]

Quando i criteri per l'elissione di un'operazione di copia sono soddisfatti e l'oggetto da copiare è designato da un valore, la risoluzione di sovraccarico per selezionare il costruttore per la copia viene prima eseguita come se l'oggetto fosse designato da un valore .

Volevo solo aggiungere un altro punto secondo cui il ritorno in base al valore dovrebbe essere la scelta predefinita qui perché un valore denominato nell'istruzione return nel caso peggiore, ovvero senza elisioni in C ++ 11, C ++ 14 e C ++ 17 viene trattato come valore. Quindi, ad esempio, la seguente funzione viene compilata con il -fno-elide-constructorsflag

std::unique_ptr<int> get_unique() {
  auto ptr = std::unique_ptr<int>{new int{2}}; // <- 1
  return ptr; // <- 2, moved into the to be returned unique_ptr
}

...

auto int_uptr = get_unique(); // <- 3

Con il flag impostato sulla compilation ci sono due mosse (1 e 2) in corso in questa funzione e poi una mossa più avanti (3).

Questo non è in alcun modo specifico std::unique_ptr, ma si applica a qualsiasi classe che sia mobile. È garantito dalle regole della lingua poiché si ritorna per valore. Il compilatore tenta di eludere le copie, invoca un costruttore di mosse se non può rimuovere copie, chiama un costruttore di copie se non può spostarsi e non riesce a compilare se non può copiare.

Se avessi una funzione che accetta std::unique_ptrcome argomento non saresti in grado di passarci sopra. Dovresti invocare esplicitamente il costruttore di spostamento, ma in questo caso non dovresti usare la variabile p dopo la chiamata a bar().

void bar(std::unique_ptr<int> p)
{
    // ...
}

int main()
{
    unique_ptr<int> p = foo();
    bar(p); // error, can't implicitly invoke move constructor on lvalue
    bar(std::move(p)); // OK but don't use p afterwards
    return 0;
}

unique_ptr non ha il tradizionale costruttore di copie. Invece ha un "costruttore di spostamento" che utilizza riferimenti a valori:

unique_ptr::unique_ptr(unique_ptr && src);

Un riferimento di valore (la doppia e commerciale) si legherà solo a un valore. Ecco perché ricevi un errore quando provi a passare un valore_valore unique_ptr a una funzione. D'altra parte, un valore che viene restituito da una funzione viene trattato come un valore, quindi il costruttore di movimenti viene chiamato automaticamente.

A proposito, questo funzionerà correttamente:

bar(unique_ptr<int>(new int(44));

Univoco_ptr temporaneo qui è un valore.

Penso che sia perfettamente spiegato nell'articolo 25 di Effective Modern C ++ di Scott Meyers . Ecco un estratto:

La parte della benedizione standard che la RVO continua dicendo che se le condizioni per la RVO sono soddisfatte, ma i compilatori scelgono di non eseguire l'elisione della copia, l'oggetto da restituire deve essere trattato come un valore. In effetti, lo Standard richiede che quando RVO è consentito, sia l'elezione della copia abbia luogo o std::movesia implicitamente applicata agli oggetti locali restituiti.

Qui, RVO si riferisce all'ottimizzazione del valore di ritorno , e se le condizioni per l'RVO sono soddisfatte significa restituire l'oggetto locale dichiarato all'interno della funzione che ci si aspetterebbe di fare l' RVO , che è anche ben spiegato al punto 25 del suo libro facendo riferimento a lo standard (qui l' oggetto locale include gli oggetti temporanei creati dall'istruzione return). Il più grande take away dall'estratto è o l'elezione della copia avviene o std::moveviene implicitamente applicata agli oggetti locali che vengono restituiti . Scott menziona l'articolo 25 che std::moveè implicitamente applicato quando il compilatore sceglie di non eludere la copia e il programmatore non dovrebbe esplicitamente farlo.

Nel tuo caso, il codice è chiaramente un candidato per RVO in quanto restituisce l'oggetto locale pe il tipo di pè lo stesso del tipo restituito, che si traduce in una copia elisione. E se il compilatore avesse scelto di non eludere la copia, per qualsiasi motivo, std::movesarebbe entrato in riga 1.

Una cosa che non ho visto in altre risposte èPer chiarire un'altra risposta che esiste una differenza tra il ritorno di std :: unique_ptr che è stato creato all'interno di una funzione, e quello che è stato dato a quella funzione.

L'esempio potrebbe essere così:

class Test
{int i;};
std::unique_ptr<Test> foo1()
{
    std::unique_ptr<Test> res(new Test);
    return res;
}
std::unique_ptr<Test> foo2(std::unique_ptr<Test>&& t)
{
    // return t;  // this will produce an error!
    return std::move(t);
}

//...
auto test1=foo1();
auto test2=foo2(std::unique_ptr<Test>(new Test));