@@ -36,7 +36,8 @@
         1.  Constructor
             1.  [Most vexing parse](most_vexing_parse.cpp)
             1.  [Delegating constructor](delegating_constructor.cpp)
-            1.  [Implicitly deleted constructor](implicitly_deleted_constructor.cpp)
+            1.  [Implicitly defined functions](implicitly_defined.cpp)
+                1.  [Implicitly deleted constructor](implicitly_deleted_constructor.cpp)
             1.  [Constructor init object member](constructor_init_object_member.cpp)
             1.  [Initializer list constructor](initializer_list_constructor.cpp)
                 1.  [Aggregate](aggregate.cpp)
@@ -98,8 +99,9 @@
         1.  [pair](pair.cpp)
         1.  [tuple](tuple.cpp)
     1.  Smart pointers
-        1. [unique_ptr](unique_ptr.cpp)
-        1. [shared_ptr](shared_ptr.cpp)
+        1.  [unique_ptr](unique_ptr.cpp)
+        1.  [shared_ptr](shared_ptr.cpp)
+            1.  [Function that maybe returns static](func_ret_maybe_static.cpp)
 1.  [Interactive](interactive/)
     1.  [bst_vs_heap](interactive/bst_vs_heap.cpp)
     1.  [chrono](interactive/chrono.cpp)
 
@@ -0,0 +1,64 @@
+// https://stackoverflow.com/questions/53304666/how-to-make-a-function-that-can-return-either-a-static-or-automatic-storage-obje
+// https://stackoverflow.com/questions/24344479/how-can-a-function-in-c-return-either-a-value-or-a-reference-with-minimal-copy
+
+#include <cassert>
+#include <iostream>
+#include <memory>
+
+struct C {
+    int i;
+    static int count;
+    C(int i) : i(i) {
+        std::cout << "constr" << std::endl;
+        count++;
+    }
+    C(const C& c) : C(c.i) {
+        std::cout << "copy" << std::endl;
+    }
+    ~C() {
+        std::cout << "destr" << std::endl;
+        count--;
+    }
+};
+int C::count = 0;
+
+std::shared_ptr<C> func_reg_maybe_static(int i) {
+    static auto static_obj = std::make_shared<C>(0);
+    if (i == 0) {
+        return static_obj;
+    } else {
+        return std::make_shared<C>(i);
+    }
+}
+
+int main() {
+    assert(C::count == 0);
+
+    {
+        auto c(func_reg_maybe_static(0));
+        assert(c->i == 0);
+        assert(C::count == 1);
+    }
+    assert(C::count == 1);
+
+    {
+        auto c(func_reg_maybe_static(0));
+        assert(c->i == 0);
+        assert(C::count == 1);
+    }
+    assert(C::count == 1);
+
+    {
+        auto c(func_reg_maybe_static(1));
+        assert(c->i == 1);
+        assert(C::count == 2);
+    }
+    assert(C::count == 1);
+
+    {
+        auto c(func_reg_maybe_static(2));
+        assert(c->i == 2);
+        assert(C::count == 2);
+    }
+    assert(C::count == 1);
+}
@@ -0,0 +1,24 @@
+// Implicitly defined functions
+//
+// https://stackoverflow.com/questions/12340257/default-vs-implicit-constructor-in-c
+// https://blog.mozilla.org/nfroyd/2015/08/20/explicit-is-better-than-implicit-c-implicitly-defined-member-functions/
+// https://stackoverflow.com/questions/3734247/what-are-all-the-member-functions-created-by-compiler-for-a-class-does-that-hap
+// https://stackoverflow.com/questions/4943958/conditions-for-automatic-generation-of-default-copy-move-ctor-and-copy-move-assi
+// https://en.cppreference.com/w/cpp/language/copy_constructor
+// https://en.cppreference.com/w/cpp/language/move_constructor
+// https://en.cppreference.com/w/cpp/language/copy_assignment
+// https://en.cppreference.com/w/cpp/language/move_assignment
+
+#include "common.hpp"
+
+int main() {
+    struct C {
+        C() = default;
+        C(const C&) = default;
+        C& operator=(C&) = default;
+        C& operator=(const C&) = default;
+        C(C&&) = default;
+        C& operator=(C&&) = default;
+        ~C() = default;
+    };
+}