Différences

Ci-dessous, les différences entre deux révisions de la page.

--- lang:cpp:smartptr [2022/10/18 13:30] – Ajout de "indirect_value" root
+++ lang:cpp:smartptr [2025/07/06 16:33] (Version actuelle) – [Préserver l'attribut const sur les pointeurs] : déplacement dans un article dédié root
@@ Ligne 1: / Ligne 1: @@
 {{ :lang:cpp:smartptr:cpp_smart_pointers_ebook.pdf |C++ smart pointers fluentcpp}}
-====std::weak_ptr en tant que clé dans un conteneur====
+====Durée de vie====
-Il faut utiliser le comparateur ''owner_less''.
-<code cpp>
-std::map<U, T, std::owner_less<U>> destination;
-</code>
-====Préserver l'attribut const sur les pointeurs====
+Lors d'un ''reset'', le nouvel objet commence par être construit avant de détruire le précédent. Si les objets ont une place importante en mémoire, il peut être intéressant de commencer par faire un ''reset()'' avant de faire le ''reset(...)''.
-Il faut utiliser ''std::propagate_const<std::unique_ptr<X%%>>%%''.
-Il existe aussi ''indirect_value'' qui peut se substituer à ''std::propagate_const<std::unique_ptr<X%%>>%%''. Attention, ''indirect_value'' ne permet pas de se substituer à ''std::propagate_const<std::shared_ptr<X%%>>%%'' (voir [[https://github.com/jbcoe/indirect_value/issues/106|Can I replace shared_ptr by indirect_value ?]] {{ :lang:cpp:smartptr:can_i_replace_shared_ptr_by_indirect_value_issue_106_jbcoe_indirect_value_github_18_10_2022_13_27_26_.html |Archive du 04/08/2022 le 18/10/2022}}).
+<code cpp>
+#include <iostream>
+#include <memory>
-Soit la classe commune ''X'' :
+class A {
+ public:
-<code cpp>
+  A() { std::cout << "Constructor\n"; }
-struct X
+  ~A() { std::cout << "Destructor\n"; }
-{
-  void g() const { std::cout << "g (const)\n"; }
-  void g() { std::cout << "g (non-const)\n"; }
 };
-</code>
-et le programme commun :
+int main() {
+  std::shared_ptr<A> a = std::make_shared<A>();
-<code cpp>
+  a.reset(new A());
-int main()
+  a = std::make_shared<A>();
-{
-  Y y;
-  y.f();
-  const Y cy;
-  cy.f();
 }
 </code>
-  * Cas avec la classe ''X'' intégrée dans une classe ''Y'' avec pointeur classique
+Sortie :
-<code cpp>
+<code>
-struct Y
+Constructor
-{
+Constructor
-  Y() { }
+Destructor
+Constructor
+Destructor
+Destructor
+</code>
-  void f() const
-  {
-    std::cout << "f (const)\n";
-    m_ptrX.g();
-  }
-  void f()
+====Encapsuler fopen/close====
-  {
-    std::cout << "f (non-const)\n";
-    m_ptrX.g();
-  }
-  // Ici, X est une instance sans pointeur.
+<code cpp>
-  X m_ptrX;
+std::unique_ptr<FILE, decltype(&fclose)> fp(std::fopen(filename.c_str(), "r"), &fclose);
-};
 </code>
-Rendu sans surprise :
+[[https://stackoverflow.com/questions/26360916/using-custom-deleter-with-unique-ptr|using custom deleter with unique_ptr]] {{ :lang:cpp:smartptr:c_-_using_custom_deleter_with_unique_ptr_-_stack_overflow_28_12_2022_10_34_58_.html |Archive du 14/10/2014 le 28/12/2022}}
-<code>
+====weak_ptr====
-f (non-const)
-g (non-const)
+====std::weak_ptr en tant que clé dans un conteneur====
-f (const)
+Il faut utiliser le comparateur ''owner_less''.
-g (const)
+<code cpp>
+std::map<U, T, std::owner_less<U>> destination;
 </code>
-Si la méthode ''f const'' est appelée, la méthode ''g const'' est appelée également car une méthode ''const'' ne peut pas appeler une méthode non ''const''.
+===Différencier empty et expired===
-  * Cas avec un pointeur intelligent
+Sans passer par ''.lock()'' pour ''empty()''.
 <code cpp>
-struct Y
+#include <iostream>
-{
+#include <memory>
-  Y() : m_ptrX{} { }
-  void f() const
+class A {};
+int main() {
   {
-    std::cout << "f (const)\n";
+    std::weak_ptr<A> aa;
-    m_ptrX->g();
+    if (!aa.owner_before(std::weak_ptr<A>{}) && !std::weak_ptr<A>{}.owner_before(aa)) {
+      std::cout << "empty1\n";
+    }
+    if (aa.expired()) {
+      std::cout << "expired1\n";
+    }
   }
-  void f()
   {
-    std::cout << "f (non-const)\n";
+    std::shared_ptr<A> a;
-    m_ptrX->g();
+    std::weak_ptr<A> aa = a;
+    if (!aa.owner_before(std::weak_ptr<A>{}) && !std::weak_ptr<A>{}.owner_before(aa)) {
+      std::cout << "empty2\n";
+    }
+    if (aa.expired()) {
+      std::cout << "expired2\n";  // False
+    }
   }
-  std::unique_ptr<X> m_ptrX;
+  {
-};
+    std::weak_ptr<A> aa;
-</code>
+    {
+      std::shared_ptr<A> a = std::make_shared<A>();
+      aa = a;
-Rendu :
+      if (!aa.owner_before(std::weak_ptr<A>{}) && !std::weak_ptr<A>{}.owner_before(aa)) {
+        std::cout << "empty3\n";  // False
-<code cpp>
+      }
-f (non-const)
+      if (aa.expired()) {
-g (non-const)
+        std::cout << "expired3\n";  // False
-f (const)
+      }
-g (non-const)
+    }
-</code>
+    if (!aa.owner_before(std::weak_ptr<A>{}) && !std::weak_ptr<A>{}.owner_before(aa)) {
+      std::cout << "empty4\n";  // False
-On ne respecte l'obligation d'appeler des méthodes ''const'' depuis une méthode ''const''.
+    }
+    if (aa.expired()) {
-  * Cas avec un pointeur unique et propagate_const
+      std::cout << "expired4\n";
+    }
-Prérequis : minimum clang 3.9, gcc 6.1. Pas dans Visual Studio 2017 [[https://github.com/jbcoe/propagate_const|sauf sur GitHub]].
+  }
+  return 0;
-<code cpp>
+}
-#include <experimental/propagate_const>
-  std::experimental::propagate_const<std::unique_ptr<X>> m_ptrX;
-</code>
-Rendu :
-<code>
-f (non-const)
-g (non-const)
-f (const)
-g (const)
 </code>