E 'corretto restituire null shared_ptr?

Question

Ad esempio, esiste una funzione che trova un oggetto e restituisce shared_ptr se viene trovato l'oggetto e deve indicare in qualche modo che nessun oggetto è stato trovato.

std::vector<std::shared_ptr> Storage::objects; 

std::shared_ptr<Object> Storage::findObject() 
{ 
    if (objects.find) 
    { 
    return objects[x]; 
    } 
    else 
    { 
    return nullptr; 
    } 
} 

std::shared_ptr<Object> obj = Storage::findObject(); 
if (obj) 
{ 
    print("found"); 
} 
else 
{ 
    print("not found"); 
} 

1. È esatto per tornare shared_ptr implicitamente inizializzato con nullptr come nell'esempio in alto? Funzionerà, ma può essere fatto in questo modo? O dovrei restituire shared_ptr predefinito costruito invece?

2. Che cosa sarebbe se fosse weak_ptr? Qual è il modo corretto per verificare che sia stato restituito weak_ptr vuoto? da weak_ptr :: funzione scaduta o ci sono altri modi? Se il controllo di weak_ptr :: expired è l'unico modo, allora come posso distinguere quella funzione che ha restituito un puntatore vuoto o l'oggetto è stato appena cancellato (ambiente multi-thread)?

Answer 1

È esatto per tornare shared_ptr implicitamente inizializzato con nullptr come nell'esempio in alto?

Sì, è corretto inizializzare shared_ptr con nullptr. È anche corretto assegnare nullptr a shared_ptr.

Oppure dovrei restituire il valore predefinito di shared_ptr costruito?

È possibile farlo in entrambi i modi: il ritorno shared_ptr inizializzato con nullptr e tornando shared_ptr di default costruito. Entrambi i modi sono corretti ed entrambi hanno lo stesso effetto. Puoi usare come vuoi.

Che cosa sarebbe se fosse weak_ptr? Qual è il modo corretto per verificare che sia stato restituito weak_ptr vuoto? da weak_ptr :: funzione scaduta o ci sono altri modi?

weak_ptr diventa nullptr (scade) quando l'ultimo shared_ptr associato all'oggetto è distrutto.

Il modo corretto di lavorare con weak_ptr è quello di convertirlo in shared_ptr con lock metodo, e poi lavorare con creato shared_ptr. In tal caso il tuo weak_ptr non scadrà finché non avrai quel nuovo shared_ptr. Se non converti weak_ptr in shared_ptr, il tuo weak_ptr potrebbe scadere in qualsiasi momento.

E sì, prima di lavorare con appena creato shared_ptr, è necessario controllare che non è nullo, perché weak_ptr può erano stati scaduto prima si è creato con shared_ptrlock metodo.

std::weak_ptr<Object> Storage::findObject(); 

... 

std::weak_ptr <Object> weak = Storage::findObject(); 
std::shared_ptr<Object> shared = weak.lock(); 
if (shared) // check that weak was not expired when we did "shared = weak.lock()" 
{ 
    // do something with shared, it will not expire. 
}