refactoring

Author: gsimsekfb

src/const-cast.cpp

@@ -12,39 +12,40 @@ namespace {
 
 // const_cast
 // - const_cast is the only cast that can add/remove const (or volatile)
-//   from a type.
+//   from a type — nothing else
 // - main legitimate use: interop with legacy C APIs lacking const correctness
 // - if you need const_cast a lot — fix the API instead
 //
 // Key notes:
-// - only cast that adds/removes const and volatile — nothing else
 // - removing const is safe ONLY if original object was not declared const
 // - modifying a truly const object after const_cast = UB
 // - prefer mutable over const_cast for class members
 
 
 //// remove const — call legacy C API that isn't const-correct
-void c_api(char* s) {  // old C API — doesn't modify s but not const
-    printf("%s", s);
+void c_api(char* ch) {  // old C API — doesn't modify ch but not const
+    printf("%s", ch);
 }
 
 TEST_CASE("con-cas-1") {
 
     const char* msg = "hello";
+    // c_api(const_cast<char*>(msg)); // ✓ safe — c_api doesn't modify it
     c_api(const_cast<char*>(msg)); // ✓ safe — c_api doesn't modify it
+        // remove constness and cast msg to char*
 
 
     //// remove const — only safe if original object was not const
     const int* ptr = new int(42); // pointer to const int, !! but underlying 
                                   // object is still not const !! 
-    int* mp = const_cast<int*>(ptr);
-    *mp = 99;                      // ✓ safe — original object was non-const
+    int* mut_ptr = const_cast<int*>(ptr);
+    *mut_ptr = 99;                      // ✓ safe — original object was non-const
     REQUIRE(*ptr == 99);
     delete ptr;
 
     const int x = 42; // !! underlying object is const !!
-    int* mut_ptr = const_cast<int*>(&x);
-    *mut_ptr = 99;                 // ❌ UB — original object IS const
+    int* mut_ptr_2 = const_cast<int*>(&x);
+    *mut_ptr_2 = 99;                 // ❌ UB — original object IS "truly" const
     REQUIRE(x == 42);
 
 
@@ -65,8 +66,6 @@ TEST_CASE("con-cas-1") {
         }
     };
 
-
-
 }
 
 }

src/local-static-objs.cpp

@@ -20,19 +20,18 @@ namespace {
 // across TUs: order of destruction matches reverse of construction order ✓
 //
 //// Key notes:
-// - initialized on first call — not at program start (lazy)
-// - destroyed at program exit — reverse construction order
-// - thread-safe initialization since C++11 — no manual mutex needed
 // - combine with constinit (C++20) for compile-time init guarantee
 // - static local vs static member: local = lazy; member = eager at startup
-// - singleton via local static is the safest C++ singleton pattern
 
 
 //// singleton pattern — most common use
+// - singleton via local static is the safest C++ singleton pattern
 class Logger {
 public:
     static Logger& instance() {
-        static Logger log;   // created once on first call ✓
+        static Logger log;
+            // created on first call — not at program start (lazy)
+            // destroyed at program exit — reverse construction order
         return log;          // thread-safe since C++11
     }
 private:
@@ -43,11 +42,10 @@ TEST_CASE("loc-sta-1") {
     Logger logger = Logger::instance();
 }
 
-
 TEST_CASE("loc-sta-2") {
 
     struct Foo {};
-    //// thread safety — C++11 guarantees
+    //// - thread-safe initialization since C++11 — no manual mutex needed
     static Foo obj; // if two threads call simultaneously:
                     // one initializes, other waits until ctor ends — no race ✓
                     // guaranteed by standard since C++11

src/variadic-templates-cpp11.cpp

@@ -16,23 +16,22 @@ using namespace std;
 // - the foundation of std::tuple, std::make_shared, and perfect forwarding.
 //
 // Key notes:
-// - typename... Args = parameter pack (types)
-// - Args...  args    = pack expansion
-// - sizeof...(Args)  = count at compile time
-// - ... placement matters — Args... expands the pack
 // - C++11: recursion to process pack; C++17: fold expressions (prefer)
 // - foundation of: tuple, make_shared, make_unique, std::invoke, std::apply
 
 
 //// basic — accept any number/type of args
+// - typename... Args = parameter pack (types)
+// - Args...  args    = pack expansion
+// - ... placement matters — Args... expands the pack
 template<typename... Args>
 void print(Args... args) {
     (std::cout << ... << args);   // fold expression (C++17) ✓
 }
 // print(1, " ", 3.14, " ", "hi");  // ✓ any types, any count
 
 
-//// sizeof... — count params
+//// - sizeof...(Args)  = count at compile time
 template<typename... Args>
 void countArgs(Args... args) {
     std::cout << sizeof...(args);  // number of args ✓