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; Base(){} Base(Base::UPtr n):next(std::move(n)){} virtual ~Base(){} void setNext(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 std; unique_ptr<int> foo() { unique_ptr<int> p( new int(10) ); return p; // …
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 construction?
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 included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/mingw32/bits/c++allocator.h:34:0, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/allocator.h:48, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/memory:64, from main.cpp:6: c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function 'void __gnu_cxx::new_allocator<_Tp>::construct(_Tp*, const …
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 = std::make_unique<SomeUserDefinedType>(1, 2, 3); Cela cache newbien et ne mentionne le type qu'une seule …
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 incomplet, à la ligne 304 dans <memory>: Application non valide de ' sizeof' à un type incomplet …
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 je le ferais, mais si je le faisais)) ou …
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 semble que tout le …
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() { std::unique_ptr<Bar, …
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 int(1));
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; // ill-formed;
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 sûre?
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 le pointeur brut, puis appelle g()et une exception est levée …
We use cookies and other tracking technologies to improve your browsing experience on our website,
to show you personalized content and targeted ads, to analyze our website traffic,
and to understand where our visitors are coming from.
By continuing, you consent to our use of cookies and other tracking technologies and
affirm you're at least 16 years old or have consent from a parent or guardian.