Quels sont les avantages d’utiliser std::make_unique sur l’opérateur new pour initialiser un std::unique_ptr ? En d’autres termes, pourquoi std::unique_ptr a = std::make_unique(SomeObject(…)) mieux que de faire std::unique_ptr a = new SomeObject(…) J’ai essayé de regarder en ligne beaucoup et je sais que c’est une bonne règle de base pour éviter l’opérateur new en C ++ […]
std::unique_ptr p1(new int); std::unique_ptr p2(new int); p2=p1; Il semble ici que p1 n’est plus “unique” puisque p2 s’y réfère aussi C’est du c ++ légal? Est-ce que unique_ptr a copy_semantics? Si non, et s’il n’a que la sémantique de déplacement, est-ce que p1 est défini sur NULL après l’affecter à p2? MODIFIER: ok donc la […]
J’ai un object C ++ de type ObjectArray typedef map<int64_t, std::unique_ptr> ObjectArray; Quelle est la syntaxe pour créer un unique_ptr à un nouvel object de type Class1 et l’insérer dans un object de type ObjectArray ?
Disons que j’ai des fonctions d’usine traitant des classes de base et dérivées: #include using namespace std; struct B { virtual ~B() {} }; struct D : B {}; unique_ptr MakeB() { auto b = unique_ptr( new B() ); return b; // Ok! } unique_ptr MakeD() { auto d = unique_ptr( new D() ); return […]
Si je comprends bien, un weak_ptr pas le compte de référence de l’object géré, par conséquent, il ne représente pas la propriété. Il vous permet simplement d’accéder à un object dont la durée de vie est gérée par quelqu’un d’autre. Donc, je ne vois pas vraiment pourquoi un weak_ptr ne peut pas être construit à […]
std::unique_ptr::get ne std::unique_ptr::get pas le but d’avoir un unique_ptr en premier lieu? Je m’attendrais à ce que cette fonction change d’état pour ne plus avoir de pointeur. Existe-t-il un usage utile de std :: unique_ptr :: get?
Étant donné la situation courante dans laquelle la durée de vie d’un object appartenant à un propriétaire est liée à son propriétaire, je peux utiliser un pointeur unique de deux façons. . Il peut être assigné: class owner { std::unique_ptr owned; public: owner() { owned=std::unique_ptr(new someObject()); } }; La méthode de réinitialisation peut être utilisée: […]
Je suis confondu avec la philosophie unique_ptr et rvalue move. Disons que nous avons deux collections: std::vector<std::auto_ptr> autoCollection; std::vector<std::unique_ptr> uniqueCollection; Maintenant, je m’attendrais à ce que les problèmes suivants échouent, car il n’y a pas d’indication de ce que fait l’algorithme en interne et peut-être de faire des copies pivot internes et autres, éliminant ainsi […]
J’essaie de comprendre comment fonctionne std::unique_ptr et pour cela j’ai trouvé ce document. L’auteur part de l’exemple suivant: #include //declarations of unique_ptr using std::unique_ptr; // default construction unique_ptr up; //creates an empty object // initialize with an argument unique_ptr uptr (new int(3)); double *pd= new double; unique_ptr uptr2 (pd); // overloaded * and -> *uptr2 […]
J’essaie de comprendre comment / si je peux utiliser unique_ptr dans une queue . // create queue std::queue<std::unique_ptr> q; // add element std::unique_ptr p (new int{123}); q.push(std::move(p)); // try to grab the element auto p2 = foo_queue.front(); q.pop(); Je comprends pourquoi le code ci-dessus ne fonctionne pas. Puisque le front et le pop sont 2 […]