J'ai une classe Foo
class Foo;
une usine qui lui renvoie un pointeur:
std::unique_ptr<Foo> createFoo();
et, comme on m'a dit par Herb qu'une fonction simple sans revendication spéciale sur la durée de vie de Foo devrait prendre des pointeurs nus simples:
void plainf(Foo* f);
Comment mon client est-il censé procéder correctement?
plainF(createFoo());
Il ne serait pas content s'il devait écrire:
auto someName = createFoo();
plainF(someName.get());
Vous pouvez utiliser la fonction membre get
qui renvoie un pointeur brut vers l'objet possédé.
plainF(createFoo().get());
Le temporaire créé par createFoo()
ne sortira pas de la portée tant que plainF
ne sera pas terminé. Tant que plainF
ne passe pas le pointeur hors de portée, cela est complètement sûr.
Si vous n'avez pas besoin que l'argument plainF
soit nul, vous pouvez également modifier sa signature pour prendre l'argument par référence, ce qui permet une syntaxe légèrement moins verbeuse:
std::unique_ptr<Foo> createFoo();
void plainf(Foo& f);
plainF(*createFoo());
Toutes les considérations de durée de vie mentionnées dans réponse de NathanOliver s'appliquent, c'est donc tout aussi sûr à utiliser.
Notez que cela implique que createFoo
ne renverra jamais un unique_ptr
Vide. Donc, si cette fonction est autorisée à échouer, vous devez indiquer cette erreur par d'autres moyens, par exemple. en lançant une exception.