Align cpp demos with docs 41-50 (extern through functions)

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

- src/extern/variable/{main.cpp,global.h,global.cpp}: two-TU demo of extern
  variable across translation units (global.h declares, global.cpp defines,
  main.cpp reads + writes).
- src/extern/function/{main.cpp,foo.c,foo.h}: extern "C" linkage of a C
  function called from C++. foo.h guards `extern "C"` under __cplusplus.
- src/filesystem.cpp: self-contained /tmp/fs_demo walkthrough — path
  decomposition, create_directory/_directories, exists/is_*, file_size,
  copy_file/copy, current_path, absolute/relative, last_write_time,
  directory_iterator/recursive_directory_iterator, remove/remove_all.
- src/fork.cpp: parent/child branching via fork() return value, getpid(),
  global vs stack copy-on-write, parent waits for child to avoid zombie.
- Create src/format.cpp: {} substitution, width/alignment/fill, precision,
  base/sign/zero-padding, positional args, chrono, custom std::formatter,
  format_to, vformat. std::print/println gated on __cpp_lib_print.
- src/forward.cpp: minimal Resource with printable copy/move ctors; lvalue
  and rvalue f() overloads; wrap() loses category, wrap_forward() preserves
  it via std::forward<T>.
- Create src/functions.cpp: index pointing at function_pointer / function /
  bind / lambda / callbacks / inline_functions for shared topics, plus tiny
  unique demos (constexpr, noexcept, return-by-value, ref-to-member,
  const-ref return).
- CMakeLists: add extern_variable / extern_function / filesystem / format /
  functions executables; project switched to LANGUAGES CXX C for foo.c.
- Skipped fPIE_and_fPIC.md, generating_and_debugging_dump_file.md,
  get_the_release_version_github.md, getting_version_from_git_in_CMake.md
  (all meta-docs about tools/build flags with no companion cpp).

Author: behnamasadi

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.20)
-project(cpp_tutorials LANGUAGES CXX)
+project(cpp_tutorials LANGUAGES CXX C)
 
 # This project uses per-config output directories, so it requires a
 # multi-config generator. Ninja Multi-Config is the recommended choice.
@@ -62,6 +62,7 @@ endif()
 # ---------------------------------------------------------------------------
 add_executable(pointers src/pointers/pointers.cpp)
 add_executable(string src/string.cpp)
+add_executable(format src/format.cpp)
 add_executable(exception_handling src/exception_handling.cpp)
 add_executable(assert src/assert.cpp)
 add_executable(return_abort_exit src/return_abort_exit.cpp)
@@ -90,9 +91,11 @@ add_executable(iterator_loop src/iterator_loop.cpp)
 add_executable(function_pointer src/function_pointer.cpp)
 add_executable(bind src/bind.cpp)
 add_executable(function src/function.cpp)
+add_executable(functions src/functions.cpp)
 add_executable(lambda src/lambda.cpp)
 add_executable(unions src/unions.cpp)
 add_executable(basic_IO_operation_streams src/basic_IO_operation_filesystem_streams_reading_writing_files_formating_output_cin_cout_scanf_printf_gets_puts_getline.cpp)
+add_executable(filesystem src/filesystem.cpp)
 add_executable(const_constexpr_mutable src/const_constexpr_mutable.cpp)
 add_executable(literals src/literals.cpp)
 add_executable(ternary src/ternary.cpp)
@@ -162,6 +165,14 @@ add_executable(circular_dependency
     src/class/circular_dependency/classA.cpp
     src/class/circular_dependency/classB.cpp)
 
+# extern: cross-TU global variable and extern "C" linkage to a C function.
+add_executable(extern_variable
+    src/extern/variable/main.cpp
+    src/extern/variable/global.cpp)
+add_executable(extern_function
+    src/extern/function/main.cpp
+    src/extern/function/foo.c)
+
 # ---------------------------------------------------------------------------
 # Advanced C++ concepts / idioms
 # ---------------------------------------------------------------------------

src/extern/function/foo.c

@@ -1,3 +1,7 @@
+#include <stdio.h>
+
 #include "foo.h"
 
-void foo() { printf("foo here"); }
+// Defined in a .c file, compiled by the C compiler. Its symbol is plain
+// "foo", with no C++ name mangling.
+void foo(void) { printf("foo here (from C)\n"); }

src/extern/function/foo.h

@@ -1 +1,15 @@
-void foo();
+#pragma once
+
+// This header is shared between foo.c (C compiler) and main.cpp (C++ compiler).
+// When the C++ side includes it, we wrap the declarations in extern "C" so the
+// C++ compiler uses C-style (non-mangled) linkage and matches the symbol that
+// the C compiler produced for foo().
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void foo(void);
+
+#ifdef __cplusplus
+}
+#endif

src/extern/function/main.cpp

@@ -1,12 +1,19 @@
-/*
-c++ mangle the name of functions so it will be able to overload function, while
-in "c", there is no overloading and function will have the same name in object
-file as what they had in their respective "c" file, so if we want to compile a
-"c" function in c++, we have to use it extern
+// Demo: calling a C function from C++.
+//
+// C++ mangles function names to support overloading; C does not. If we
+// declared foo() with normal C++ linkage, the linker would look for a
+// mangled symbol that the C compiler never produced. 'extern "C"' tells
+// the C++ compiler to use C linkage for these declarations so the names
+// match.
+//
+// foo.h already wraps its declarations in extern "C" when __cplusplus is
+// defined, so a plain #include is enough here.
+
+#include <iostream>
 
-*/
-extern "C" {
 #include "foo.h"
-}
 
-int main() { foo(); }
+int main() {
+  std::cout << "calling C function from C++:\n";
+  foo();
+}

src/extern/variable/global.cpp

@@ -0,0 +1,3 @@
+// The single definition of g_value lives here. Other translation units
+// see it through the 'extern' declaration in global.h.
+int g_value = 10;

src/extern/variable/global.h

@@ -0,0 +1,5 @@
+#pragma once
+
+// Declaration only: 'extern' tells the compiler that g_value is
+// defined in some other translation unit. No storage is reserved here.
+extern int g_value;

src/extern/variable/main.cpp

@@ -1,83 +1,18 @@
-/*
- * Extern.cpp
- *
- *  Created on: Feb 22, 2012
- *      Author: behnam
- */
-#include <iostream>
-/*http://www.learncpp.com/cpp-tutorial/42-global-variables/
- * Variables declared outside of a block are called global variables. Global
-variables have program scope,
- * which means they can be accessed everywhere in the program, and they are only
-destroyed when the program ends.
-
-int g_nX; // global variable
-
-int main()
-{
-    int nY; // local variable nY
-
-    // global vars can be seen everywhere in program
-    // so we can change their values here
-    g_nX = 5;
-} // nY is destroyed here
-
- */
-
-/*
-In order to use a global variable that has been declared in another file, you
-have to use a forward declaration or a header file, along with the extern
-keyword.
-
-
-global.cpp:
-        // declaration of g_nValue
-        int g_nValue = 5;
-
-main.cpp:
-        // extern tells the compiler this variable is declared elsewhere
-        extern int g_nValue;
-
-        int main()
-        {
-                g_nValue = 7;
-                return 0;
-        }
-
-
-_________________________________________________________________________________________________________________
-
-Here is an example of using a header file extern:
-
-global.cpp:
-
-        // declaration of g_nValue
-        int g_nValue = 5;
-
-global.h:
-        #ifndef GLOBAL_H // header guards
-        #define GLOBAL_H
-
-        // extern tells the compiler this variable is declared elsewhere
-        extern int g_nValue;
-
-        #endif
-
-main.cpp:
-        #include "global.h"
-        int main()
-        {
-                g_nValue = 7;
-                return 0;
-        }
+// Demo: using a global variable defined in another file via 'extern'.
+//
+//   global.cpp : int g_value = 10;        // definition
+//   global.h   : extern int g_value;      // declaration
+//   main.cpp   : includes global.h and uses g_value
+//
+// The linker resolves the reference to the definition in global.cpp.
 
+#include <iostream>
 
- */
+#include "global.h"
 
-using namespace std;
+int main() {
+  std::cout << "initial g_value: " << g_value << '\n';
 
-int Externmain()
-// in main()
-{
-  return 0;
+  g_value = 7;
+  std::cout << "after write:     " << g_value << '\n';
 }