std :: unique_ptr est un pointeur intelligent qui conserve la propriété exclusive d'un objet via un pointeur. unique_ptr n'est ni copiable ni assignable par copie, deux instances de unique_ptr ne peuvent pas gérer le même objet.
Je suis nouveau pour déplacer la sémantique en C ++ 11 et je ne sais pas très bien comment gérer les unique_ptrparamètres dans les constructeurs ou les fonctions. Considérez cette classe se référençant elle-même: #include <memory> class Base { public: typedef unique_ptr<Base> UPtr;...
unique_ptr<T>ne permet pas la construction de copie, mais prend en charge la sémantique de déplacement. Pourtant, je peux retourner un à unique_ptr<T>partir d'une fonction et affecter la valeur retournée à une variable. #include <iostream> #include <memory> using namespace...
J'ai du code dans un en-tête qui ressemble à ceci: #include <memory> class Thing; class MyClass { std::unique_ptr< Thing > my_thing; }; Si Thingj'inclus cet en-tête dans un cpp qui n'inclut pas la définition de type, cela ne se compile pas sous VS2010-SP1: 1> C: \ Program Files (x86)...
std::unique_ptr prend en charge les tableaux, par exemple: std::unique_ptr<int[]> p(new int[10]); mais est-ce nécessaire? il est probablement plus pratique à utiliser std::vectorou std::array. Trouvez-vous une utilité pour cette
Quel est le problème avec ce programme? #include <memory> #include <vector> int main() { std::vector<std::unique_ptr<int>> vec; int x(1); std::unique_ptr<int> ptr2x(&x); vec.push_back(ptr2x); //This tiny command has a vicious error. return 0; } L'erreur: In file...
Pourquoi n'y a-t-il pas de std::make_uniquemodèle de fonction dans la bibliothèque C ++ 11 standard? je trouve std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3)); un peu bavard. Les éléments suivants ne seraient-ils pas beaucoup plus agréables? auto p =...
J'utilise le pimpl-idiom avec std::unique_ptr: class window { window(const rectangle& rect); private: class window_impl; // defined elsewhere std::unique_ptr<window_impl> impl_; // won't compile }; Cependant, j'obtiens une erreur de compilation concernant l'utilisation d'un type...
Avec l'arrivée du nouveau standard (et des pièces déjà disponibles dans certains compilateurs), le nouveau type std::unique_ptrest censé remplacer std::auto_ptr. Leur utilisation se chevauche-t-elle exactement (pour que je puisse faire une recherche / remplacement globale sur mon code (non pas que...
J'ai du mal à comprendre l'utilisation des pointeurs intelligents en tant que membres de classe dans C ++ 11. J'ai beaucoup lu sur les pointeurs intelligents et je pense comprendre comment unique_ptret shared_ptr/ weak_ptrfonctionne en général. Ce que je ne comprends pas, c'est l'usage réel. Il...
J'ai une classe avec un membre unique_ptr. class Foo { private: std::unique_ptr<Bar> bar; ... }; La barre est une classe tierce qui a une fonction create () et une fonction destroy (). Si je voulais utiliser un std::unique_ptravec lui dans une fonction autonome, je pourrais faire: void foo()...
At std::make_unique- il des avantages d'efficacité comme std::make_shared? Par rapport à la construction manuelle std::unique_ptr: std::make_unique<int>(1); // vs std::unique_ptr<int>(new
Comment implémenter un constructeur de copie pour une classe qui a une unique_ptrvariable membre? Je ne considère que C ++
La question rentre vraiment dans le titre: je suis curieux de savoir quelle est la raison technique de cette différence, mais aussi la raison? std::shared_ptr<void> sharedToVoid; // legal; std::unique_ptr<void> uniqueToVoid; //
La bibliothèque standard C ++ 11 fournit-elle un utilitaire pour convertir de a std::shared_ptren std::unique_ptr, ou vice versa? Cette opération est-elle
Pour autant que je sache, C ++ 14 a été introduit std::make_uniquecar, en raison de la non-spécification de l'ordre d'évaluation des paramètres, ce n'était pas sûr: f(std::unique_ptr<MyClass>(new MyClass(param)), g()); // Syntax A (Explication: si l'évaluation alloue d'abord la mémoire pour...
J'essaie de comprendre comment std::unique_ptrfonctionne et pour cela j'ai trouvé ce document. L'auteur part de l'exemple suivant: #include <utility> //declarations of unique_ptr using std::unique_ptr; // default construction unique_ptr<int> up; //creates an empty object // initialize...
J'essaie de compiler le programme de pool de threads suivant publié sur la revue de code pour le tester. /codereview/55100/platform-independant-thread-pool-v4 Mais je reçois les erreurs threadpool.hpp: In member function ‘std::future<decltype (task((forward<Args>)(args)...))>...
Je regarde le discours de Chandler Carruth dans CppCon 2019: Il n'y a pas d'abstractions à coût nul dans ce document, il donne l'exemple de la façon dont il a été surpris par la quantité de frais généraux que vous encourez en utilisant un std::unique_ptr<int>sur un int*; ce segment commence...
J'ai écrit le code suivant qui utilise unique_ptr<Derived>où un unique_ptr<Base>est attendu class Base { int i; public: Base( int i ) : i(i) {} int getI() const { return i; } }; class Derived : public Base { float f; public: Derived( int i, float f ) : Base(i), f(f) {} float getF()...
Obtenir un à void *partir d'une fonction dans CI ferait quelque chose comme ça (exemple très basique): void *get_ptr(size_t size) { void *ptr = malloc(size); return ptr; } Comment obtenir le même résultat lors de l'utilisation