Align cpp demos with docs 31-40 (decay through explicit_constructor)

Each cpp mirrors only what its doc covers, with short labeled demos and
didactic naming.

- Create src/decay.cpp: array-to-pointer decay (sizeof inside fn vs main),
  preventing decay via T(&)[N], function-to-pointer decay, std::decay_t
  identity table.
- src/class/default_0_delete_meaning.cpp: =default trivial-ctor check,
  Noncopyable via =delete, move-only mix, =0 pure virtual Shape, implicit
  default-ctor walkthrough (A/B/C/E).
- src/double_dispatch.cpp: minimal Shape/Circle/Rectangle with two-level
  virtual dispatch via collideWith + collideWithCircle/Rectangle. Replaces
  the prior SpaceShip/Asteroid hierarchy that wasn't in the doc.
- src/dynamic_memory_allocation.cpp: C-style malloc/calloc/realloc demos
  (doc covers C allocation, not new/delete).
- src/enum.cpp: unscoped enum with bitmask via |, enum class, explicit
  underlying type, cross-enum comparison danger, iterating None..All.
- src/error_handling.cpp + src/error_code.cpp: errno + strerror + perror,
  out-param error_code, system_category() wrapping errno, filesystem
  non-throwing overload, std::errc, custom parse_category with
  is_error_code_enum, system_error throwing form.
- src/exception_handling.cpp: try/catch/catch(...), bad_alloc + nothrow,
  bad_cast/bad_typeid, logic/runtime_error subclasses, custom
  noexcept-override what(), stack-unwinding LIFO trace, noexcept fn.
- Create src/execution_policies.cpp: std::execution::seq with for_each,
  transform, reduce, sort. par/par_unseq gated behind #if 0 with a note
  about needing libtbb linked.
- src/class/explicit_constructor.cpp: implicit-conversion trap + explicit
  disables it, with a commented line showing what would not compile.

Author: behnamasadi

CMakeLists.txt

@@ -73,6 +73,7 @@ add_executable(dynamic_memory_allocation src/dynamic_memory_allocation.cpp)
 add_executable(template src/template.cpp)
 add_executable(inline_functions src/inline_functions.cpp)
 add_executable(algorithms_library src/algorithms_library.cpp)
+add_executable(execution_policies src/execution_policies.cpp)
 add_executable(vector src/vector.cpp)
 add_executable(queue src/queue.cpp)
 add_executable(variadic_templates src/variadic_templates.cpp)
@@ -97,6 +98,7 @@ add_executable(literals src/literals.cpp)
 add_executable(ternary src/ternary.cpp)
 add_executable(lists src/lists.cpp)
 add_executable(type_traits src/type_traits.cpp)
+add_executable(decay src/decay.cpp)
 add_executable(typedef_type_alias_using_keyword src/typedef_type_alias_using_keyword.cpp)
 add_executable(most_vexing_parse src/most_vexing_parse.cpp)
 add_executable(VTABLE_and_VPTR src/VTABLE_and_VPTR.cpp)

src/class/default_0_delete_meaning.cpp

@@ -1,28 +1,109 @@
-// Default constructors
-
-class foo {
-public:
-  /*
-  =0
-  C++ uses the special syntax = 0; to indicate pure virtual functions instead of
-  adding a new keyword to the language
-  */
-  void virtual pureVirtualFunction() = 0;
-  /*
-  =default
-  It means that you want to use the compiler-generated version of that function,
-  so you don't need to specify a body.
-  */
-  ~foo() = default;
-  /*
-  = delete
-      It means that the compiler will not generate those constructors for you.
-  This is only allowed on copy constructor and assignment operator
-  */
-  foo(const foo &t) = delete;
-  foo &operator=(const foo &t) = delete;
+// Meaning of =default, =delete, and =0 in C++.
+//
+// =default : ask the compiler to generate the special member function.
+// =delete  : forbid the function; calling it is a compile error.
+// =0       : on a virtual function, declare it pure virtual (abstract).
+
+#include <iostream>
+#include <type_traits>
+
+// ---------- =default ----------
+// Foo has a user-defined constructor, so the compiler would NOT generate a
+// default constructor. We explicitly default it so Foo() still works.
+struct Foo {
+  int i;
+  Foo(int a, int b) : i(a), j(b) {}
+  Foo() = default;          // explicitly defaulted -> Foo stays trivial-ish
+private:
+  int j;
+};
+
+// Replacing `Foo() = default;` with `Foo() {}` would make it non-trivial.
+struct FooEmptyBody {
+  int i;
+  FooEmptyBody(int a, int b) : i(a), j(b) {}
+  FooEmptyBody() {}         // user-provided empty body -> non-trivial
+private:
+  int j;
+};
+
+// ---------- =delete ----------
+// Noncopyable: copy operations are forbidden.
+struct Noncopyable {
+  Noncopyable() = default;
+  Noncopyable(const Noncopyable&) = delete;
+  Noncopyable& operator=(const Noncopyable&) = delete;
+};
+
+// Movable-only: copies deleted, moves defaulted.
+struct MoveOnly {
+  MoveOnly() = default;
+  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly& operator=(const MoveOnly&) = delete;
+  MoveOnly(MoveOnly&&) = default;
+  MoveOnly& operator=(MoveOnly&&) = default;
+  ~MoveOnly() = default;
+};
+
+// ---------- =0 (pure virtual) ----------
+struct Shape {
+  virtual double area() const = 0;   // pure virtual -> Shape is abstract
+  virtual ~Shape() = default;
+};
+
+struct Square : Shape {
+  double side;
+  Square(double s) : side(s) {}
+  double area() const override { return side * side; }
+};
+
+// ---------- Implicit deletion examples (from the doc) ----------
+struct A {
+  int x;
+  A(int x = 1) : x(x) {}             // user-defined default constructor
+};
+
+struct B : A { };                    // B() implicitly defined, calls A::A()
+
+struct C { A a; };                   // C() implicitly defined, calls A::A()
+
+struct E : A {
+  E(int y) : A(y) {}
+  E() = default;                     // explicitly defaulted, calls A::A()
 };
 
 int main() {
-  // foo
+  std::cout << "--- =default makes Foo trivially-constructible ---\n";
+  Foo f;
+  std::cout << "Foo() compiles, Foo.i = " << f.i << "\n";
+  std::cout << "is_trivially_default_constructible<Foo>      = "
+            << std::is_trivially_default_constructible<Foo>::value << "\n";
+  std::cout << "is_trivially_default_constructible<FooEmpty> = "
+            << std::is_trivially_default_constructible<FooEmptyBody>::value
+            << "  (empty body {} is NOT trivial)\n";
+
+  std::cout << "\n--- =delete forbids copies ---\n";
+  Noncopyable n1;
+  // Noncopyable n2 = n1;   // would not compile: copy ctor deleted
+  // n1 = n1;               // would not compile: copy assign deleted
+  (void)n1;
+  std::cout << "Noncopyable built; copy/assign would be a compile error\n";
+
+  std::cout << "\n--- move-only via =delete + =default ---\n";
+  MoveOnly m1;
+  MoveOnly m2 = std::move(m1);       // move ok
+  // MoveOnly m3 = m2;               // would not compile: copy deleted
+  (void)m2;
+  std::cout << "MoveOnly moved; copy would be a compile error\n";
+
+  std::cout << "\n--- =0 pure virtual makes a class abstract ---\n";
+  // Shape s;                        // would not compile: abstract type
+  Square sq(3.0);
+  Shape& sref = sq;
+  std::cout << "Square(3).area() via Shape& = " << sref.area() << "\n";
+
+  std::cout << "\n--- implicit default ctor follows from members/bases ---\n";
+  A a; B b; C c; E e;
+  std::cout << "A.x=" << a.x << "  B.x=" << b.x
+            << "  C.a.x=" << c.a.x << "  E.x=" << e.x << "\n";
 }

src/class/explicit_constructor.cpp

@@ -1,43 +1,60 @@
+// Explicit Constructor
+//
+// The compiler is allowed to make ONE implicit conversion to resolve the
+// arguments of a function/constructor. A single-argument constructor that is
+// not marked `explicit` therefore doubles as an implicit conversion from its
+// parameter type. This is often surprising. The `explicit` keyword disables
+// that conversion: the constructor can still be called, but only directly.
+
 #include <iostream>
 
 namespace Implicit {
 class String {
 public:
   // allocate n bytes to the String object
   String(int n) {
-    std::cout << "allocate " << n << " bytes to the String object" << std::endl;
+    std::cout << "  allocate " << n << " bytes to the String object"
+              << std::endl;
   }
 
-  // initializes object with char *p
+  // initialize object with char *p
   String(const char *p) {
-    std::cout << "initializes object with char *p" << std::endl;
+    std::cout << "  initialize object with char *p" << std::endl;
   }
 };
-
 } // namespace Implicit
 
 namespace Explicit {
-
 class String {
 public:
   // allocate n bytes
   explicit String(int n) {
-    std::cout << "allocate " << n << " bytes to the String object" << std::endl;
+    std::cout << "  allocate " << n << " bytes to the String object"
+              << std::endl;
   }
-  // initialize sobject with string p
+  // initialize object with char *p
   String(const char *p) {
-    std::cout << "initializes object with char *p" << std::endl;
+    std::cout << "  initialize object with char *p" << std::endl;
   }
 };
-
 } // namespace Explicit
 
 int main() {
-  // This is actually possible because Entity has a constructor that can get
-  // only an integer or a string
+  std::cout << "--- Implicit conversion trap ---" << std::endl;
+  // 'a' is a char, implicitly convertible to int (ASCII 97).
+  // Copy-initialization picks String(int) and allocates 97 bytes,
+  // which is almost certainly not what the caller meant.
   Implicit::String s1 = 'a';
 
-  // explicit keyword will disable the above conversion, so we should do it by
-  // casting
+  std::cout << "--- explicit disables the trap ---" << std::endl;
+  // With `explicit String(int)`, the following line no longer compiles:
+  //
+  //     Explicit::String s2 = 'a';   // error: copy-init cannot use
+  //                                  //        explicit constructor
+  //
+  // We must convert the char ourselves. Casting to const char* selects
+  // the String(const char *) constructor instead.
   Explicit::String s2 = (const char *)'a';
+
+  return 0;
 }

src/decay.cpp

@@ -0,0 +1,54 @@
+// Demo: decay in C++
+// Covers array-to-pointer decay, function-to-pointer decay,
+// preventing array decay via reference, and std::decay_t.
+
+#include <iostream>
+#include <type_traits>
+
+// Receives the array by value: it decays to int*.
+void takesPointer(int arr[10]) {
+    std::cout << "  inside takesPointer, sizeof(arr) = "
+              << sizeof(arr) << " (size of a pointer)\n";
+}
+
+// Receives the array by reference: no decay, size preserved.
+template <std::size_t N>
+void takesArrayByRef(int (&arr)[N]) {
+    std::cout << "  inside takesArrayByRef, N = " << N
+              << ", sizeof(arr) = " << sizeof(arr) << "\n";
+}
+
+// A plain function used to show function-to-pointer decay.
+int add(int a, int b) {
+    return a + b;
+}
+
+// Receives a function: name decays to a pointer.
+void callIt(int (*f)(int, int)) {
+    std::cout << "  callIt result = " << f(2, 3) << "\n";
+}
+
+int main() {
+    std::cout << "--- array-to-pointer decay ---\n";
+    int arr[10];
+    std::cout << "  in main, sizeof(arr) = " << sizeof(arr)
+              << " (10 * sizeof(int))\n";
+    takesPointer(arr);
+
+    std::cout << "--- preventing array decay (pass by reference) ---\n";
+    takesArrayByRef(arr);
+
+    std::cout << "--- function-to-pointer decay ---\n";
+    callIt(add);  // 'add' decays to a function pointer
+
+    std::cout << "--- std::decay_t ---\n";
+    std::cout << std::boolalpha;
+    std::cout << "  decay_t<int[10]> is int*: "
+              << std::is_same_v<std::decay_t<int[10]>, int*> << "\n";
+    std::cout << "  decay_t<int(int,int)> is int(*)(int,int): "
+              << std::is_same_v<std::decay_t<int(int, int)>, int(*)(int, int)> << "\n";
+    std::cout << "  decay_t<const int&> is int: "
+              << std::is_same_v<std::decay_t<const int&>, int> << "\n";
+
+    return 0;
+}