Classe de pointeur intelligent comptée par référence implémentant la propriété partagée
J'ai une solide compréhension de la plupart des théories OO, mais la seule chose qui me déroute beaucoup, ce sont les destructeurs virtuels. J'ai pensé que le destructeur est toujours appelé, peu importe quoi et pour chaque objet de la chaîne. Quand êtes-vous censé les rendre virtuels et...
std::shared_ptr<Object> p1 = std::make_shared<Object>("foo"); std::shared_ptr<Object> p2(new Object("foo")); De nombreux articles sur Google et stackoverflow sont là-dessus, mais je ne peux pas comprendre pourquoi make_sharedest plus efficace que l'utilisation directe shared_ptr....
Quand une fonction prend un shared_ptr(de boost ou C ++ 11 STL), le passez-vous: par référence const: void foo(const shared_ptr<T>& p) ou par valeur void foo(shared_ptr<T> p):? Je préférerais la première méthode car je pense qu'elle serait plus rapide. Mais cela en vaut-il vraiment...
J'ai commencé à étudier les pointeurs intelligents de C ++ 11 et je ne vois aucune utilisation utile de std::weak_ptr. Quelqu'un peut-il me dire quand std::weak_ptrest utile /
J'ai ce code qui ne fonctionne pas, mais je pense que l'intention est claire: testmakeshared.cpp #include <memory> class A { public: static ::std::shared_ptr<A> create() { return ::std::make_shared<A>(); } protected: A() {} A(const A &) = delete; const A &operator =(const...
Juste une petite question concernant shared_ptr. Est-ce une bonne pratique d'utiliser le shared_ptrpointage vers un tableau? Par exemple, shared_ptr<int> sp(new int[10]); Sinon, pourquoi pas? L'une des raisons dont je suis déjà conscient est que l'on ne peut pas augmenter / décrémenter le...
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 parcouru le code source de Clang et j'ai trouvé cet extrait: void CompilerInstance::setInvocation( std::shared_ptr<CompilerInvocation> Value) { Invocation = std::move(Value); } Pourquoi voudrais-je std::moveun std::shared_ptr? Y a-t-il un point de transfert de propriété sur une ressource...
J'ai trouvé du code en utilisant std :: shared_ptr pour effectuer un nettoyage arbitraire à l'arrêt. Au début, je pensais que ce code ne pouvait pas fonctionner, mais j'ai ensuite essayé ce qui suit: #include <memory> #include <iostream> #include <vector> class test { public:...
J'écris une méthode d'accesseur pour un pointeur partagé en C ++ qui ressemble à ceci: class Foo { public: return_type getBar() const { return m_bar; } private: boost::shared_ptr<Bar> m_bar; } Donc, pour prendre en charge la const-ness du getBar()type de retour devrait être un...
Si j'ai une fonction qui doit fonctionner avec a shared_ptr, ne serait-il pas plus efficace de lui passer une référence (pour éviter de copier l' shared_ptrobjet)? Quels sont les effets secondaires possibles? J'envisage deux cas possibles: 1) à l'intérieur de la fonction, une copie de l'argument...
Je lis http://gcc.gnu.org/onlinedocs/libstdc++/manual/shared_ptr.html et certains problèmes de sécurité des threads ne sont toujours pas clairs pour moi: Standard garantit que le comptage de références est géré thread-safe et qu'il est indépendant de la plateforme, non? Problème similaire - la...
Je suis tellement frustré en ce moment après plusieurs heures à essayer de trouver où se trouve shared_ptr. Aucun des exemples que je vois ne montre le code complet pour inclure les en-têtes pour shared_ptr(et le travail). Disant simplement std, tr1et <memory>n'aide pas du tout! J'ai...
J'essaie actuellement d'apprendre à utiliser des pointeurs intelligents. Cependant, en faisant quelques expériences, j'ai découvert la situation suivante pour laquelle je ne pouvais pas trouver de solution satisfaisante: Imaginez que vous ayez un objet de classe A étant parent d'un objet de classe...
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
Quelle est la meilleure méthode pour passer un shared_ptrd'un type dérivé à une fonction qui prend un shared_ptrd'un type de base? Je passe généralement shared_ptrs par référence pour éviter une copie inutile: int foo(const shared_ptr<bar>& ptr); mais cela ne fonctionne pas si j'essaye...
Si je déclare un objet enveloppé dans un pointeur partagé: std::shared_ptr<myClass> myClassObject(new myClass()); alors j'ai voulu le passer comme argument à une méthode: DoSomething(myClassObject); //the called method void DoSomething(std::shared_ptr<myClass> arg1) {...
Disons que j'ai un shared_ptravec un allocateur personnalisé et un suppresseur personnalisé. Je ne trouve rien dans la norme qui parle de l'endroit où le suppresseur doit être stocké: il ne dit pas que l'allocateur personnalisé sera utilisé pour la mémoire du suppresseur, et il ne dit pas qu'il ne...