Align cpp demos with docs 51-60 (google_benchmark through lexical_analyzer)

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

- src/benchmark_demo.cpp: BENCHMARK(fn) + BENCHMARK_MAIN, CustomArguments
  with Arg ranges, BENCHMARK_F fixture with SetUp/TearDown, DoNotOptimize
  + SetItemsProcessed throughput. Verified by configuring with
  ENABLE_BENCHMARKING=ON.
- src/hash.cpp: std::hash<float|int|string> primitives, custom std::hash
  specialization vs KeyHasher functor on a user-defined `student`, bucket
  interface (bucket_count/load_factor/max_load_factor/bucket_size).
- src/heap_and_stack_memory_layout_of_C_programs.cpp: print addresses for
  .text / .rodata / .data / .bss / heap / stack and confirm the expected
  ascending ordering. Replaces a 4-line empty-main stub.
- Create src/immutable_objects.cpp: ImmutablePoint with const members,
  deleted operator=, and a movedBy(dx,dy) const that returns a new copy.
- src/initialization.cpp: 10 sections mapping 1:1 to the doc (default-init,
  value-init, direct-init, copy-init, list-init, aggregate, zero-init,
  in-class member init, narrowing, std::initializer_list ctor) plus the
  declaration-order trap and a most-vexing-parse comment.
- src/iterator_loop.cpp: input/output/forward/bidirectional/random-access
  iterators, iterator_traits + category tag dispatch, minimal custom
  SampleBuffer iterator, range-based for variants, cbegin loop,
  next/advance/distance.
- src/json_example.cpp: 11 nlohmann/json sections from literals, parse,
  dump, [] vs at, iteration, STL interop, exception types, json::array,
  type checks, merge_patch, file I/O to /tmp.
- src/lambda.cpp: inline + stored lambda, file-scope lambda used with
  std::for_each, [=] mutable vs [&] vs mixed [=, &y], template + std::function
  acceptors. Removed topics the doc doesn't cover.
- Create src/lexical_analyzer.cpp: ~80-line hand-rolled lexer that
  tokenizes the doc's exact example snippet (keywords / identifiers /
  literals / scope_op :: / insertion_op << / punctuation).
- CMakeLists: add immutable_objects + lexical_analyzer executables.
- Skipped godbolt.md (meta-doc about Compiler Explorer).

Author: behnamasadi

CMakeLists.txt

@@ -97,6 +97,7 @@ 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(immutable_objects src/immutable_objects.cpp)
 add_executable(literals src/literals.cpp)
 add_executable(ternary src/ternary.cpp)
 add_executable(lists src/lists.cpp)
@@ -125,6 +126,7 @@ add_executable(memory_checking src/memory_checking.cpp)
 add_executable(tricky_questions src/tricky_questions.cpp)
 add_executable(metaprogramming src/metaprogramming.cpp)
 add_executable(regex_mathch_search src/regex_mathch_search.cpp)
+add_executable(lexical_analyzer src/lexical_analyzer.cpp)
 add_executable(optional src/optional.cpp)
 add_executable(std_invoke src/std_invoke.cpp)
 add_executable(structured_binding_declaration src/structured_binding_declaration.cpp)

src/benchmark_demo.cpp

@@ -1,19 +1,58 @@
-// https://www.youtube.com/watch?v=eKODykkIZTE&t=108s
+// Educational examples for Google Benchmark.
+// Mirrors docs/google_benchmark.md.
+
 #include <benchmark/benchmark.h>
+#include <string>
+#include <vector>
+
+// Example 1: Benchmarking a simple function.
+// The for-range loop is executed many times by the framework.
+static void StringCreation(benchmark::State& state) {
+  for (auto _ : state) {
+    std::string s("Hello, World!");
+  }
+}
+BENCHMARK(StringCreation);
 
-static void BM_StringCreation(benchmark::State &state) {
-  for (auto _ : state)
-    std::string empty_string;
+// Example 2: Benchmarking with custom arguments.
+// state.range(0) returns the value supplied via ->Arg(...).
+static void CustomArguments(benchmark::State& state) {
+  int n = state.range(0);
+  for (auto _ : state) {
+    std::vector<int> v(n);
+  }
 }
-// Register the function as a benchmark
-BENCHMARK(BM_StringCreation);
-
-// Define another benchmark
-static void BM_StringCopy(benchmark::State &state) {
-  std::string x = "hello";
-  for (auto _ : state)
-    std::string copy(x);
+BENCHMARK(CustomArguments)->Arg(1024)->Arg(2048)->Arg(4096);
+
+// Example 3: Using fixtures for setup and teardown.
+class MyBenchmarkFixture : public benchmark::Fixture {
+ public:
+  void SetUp(const ::benchmark::State& state) override {
+    // Code to set up before each benchmark iteration.
+  }
+
+  void TearDown(const ::benchmark::State& state) override {
+    // Code to clean up after each benchmark iteration.
+  }
+};
+
+BENCHMARK_F(MyBenchmarkFixture, ExampleBenchmark)(benchmark::State& state) {
+  for (auto _ : state) {
+    // Benchmark code.
+  }
+}
+
+// Example 4: Measuring throughput.
+// DoNotOptimize prevents the compiler from removing unused work.
+// SetItemsProcessed lets the report show items/second.
+static int some_operation() { return 42; }
+
+static void BM_Throughput(benchmark::State& state) {
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(some_operation());
+  }
+  state.SetItemsProcessed(state.iterations());
 }
-BENCHMARK(BM_StringCopy);
+BENCHMARK(BM_Throughput);
 
 BENCHMARK_MAIN();

src/hash.cpp

@@ -1,123 +1,102 @@
+// Hash functions and hash-based containers.
+// Follows docs/hash_function_hash_table.md.
+
 #include <iostream>
-#include <set>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 
-// user-defined hash functions:
-// Example 1
-
-class Course {
-public:
-  std::string m_name;
-  bool m_isAdvanced;
-
-  Course(std::string name, bool isAdvanced) {
-    m_name = name;
-    m_isAdvanced = isAdvanced;
-  }
-
-  bool isAdvanced() { return m_isAdvanced; }
+// ----- std::hash on built-in types ---------------------------------------
+void builtinHash() {
+  std::cout << "--- std::hash on primitives and strings ---\n";
 
-  bool operator==(const Course &rhs) const {
-    return ((rhs.m_isAdvanced == this->m_isAdvanced) &&
-            (rhs.m_name == this->m_name));
-  }
-};
-
-class CourseHashFunction {
-public:
-  std::size_t operator()(const Course &k) const {
-    // We use predfined hash functions of string and bool and define our hash
-    // function as XOR of the hash values.
-    return (std::hash<std::string>()(k.m_name)) ^
-           (std::hash<bool>()(k.m_isAdvanced));
-  }
-};
+  std::hash<float> float_hasher;
+  std::hash<int> int_hasher;
+  std::hash<std::string> str_hasher;
 
-// Example 2
+  std::cout << "hash(3.14f) = " << float_hasher(3.14f) << "\n";
+  std::cout << "hash(42)    = " << int_hasher(42) << "\n";
+  std::cout << "hash(\"hello\") = " << str_hasher("hello") << "\n";
+}
 
+// ----- User-defined type + std::hash specialization ----------------------
 class student {
 public:
   int id;
   std::string first_name;
   std::string last_name;
 
   bool operator==(const student &other) const {
-    return (first_name == other.first_name && last_name == other.last_name &&
-            id == other.id);
+    return first_name == other.first_name && last_name == other.last_name &&
+           id == other.id;
   }
 };
 
+// Specialization inside std:: lets unordered_map<student, V> work directly.
 namespace std {
-
 template <> struct hash<student> {
   std::size_t operator()(const student &k) const {
-
-    // Compute individual hash values for first,
-    // second and third and combine them using XOR
-    // and bit shifting:
-
+    // Combine field hashes with XOR and bit shifts.
     return ((std::hash<string>()(k.first_name) ^
              (std::hash<string>()(k.last_name) << 1)) >>
             1) ^
            (std::hash<int>()(k.id) << 1);
-    ;
   }
 };
-
 } // namespace std
-// If you don't want to specialize template inside the std namespace (although
-// it's perfectly legal in this case), you can define the hash function as a
-// separate class and add it to the template argument list for the map:
 
+// Alternative: a standalone hasher passed as a template argument.
 struct KeyHasher {
   std::size_t operator()(const student &k) const {
-
     return ((std::hash<std::string>()(k.first_name) ^
              (std::hash<std::string>()(k.last_name) << 1)) >>
             1) ^
            (std::hash<int>()(k.id) << 1);
   }
 };
 
-void unordered_mapCustomClasstype() {
+void userDefinedHash() {
+  std::cout << "--- user-defined hash for a class ---\n";
+
+  // Uses std::hash<student> specialization.
   std::unordered_map<student, std::string> student_umap = {
       {{1, "John", "Doe"}, "example"}, {{2, "Mary", "Sue"}, "another"}};
 
-  std::unordered_map<student, std::string, KeyHasher> m6 = {
+  // Uses KeyHasher passed as the third template argument.
+  std::unordered_map<student, std::string, KeyHasher> student_umap2 = {
       {{1, "John", "Doe"}, "example"}, {{2, "Mary", "Sue"}, "another"}};
+
+  std::cout << "student_umap  size = " << student_umap.size() << "\n";
+  std::cout << "student_umap2 size = " << student_umap2.size() << "\n";
 }
 
-void sizeOfTheHashTable() {
-  // Example with std::unordered_map
+// ----- Bucket interface --------------------------------------------------
+void bucketInterface() {
+  std::cout << "--- bucket_count / load_factor / max_load_factor ---\n";
+
   std::unordered_map<int, std::string> my_map = {
       {1, "one"}, {2, "two"}, {3, "three"}};
 
-  std::cout << "Number of buckets in my_map: " << my_map.bucket_count()
-            << std::endl;
-  std::cout << "Current load factor in my_map: " << my_map.load_factor()
-            << std::endl;
-  std::cout << "Max load factor in my_map: " << my_map.max_load_factor()
-            << std::endl;
+  std::cout << "my_map bucket_count    = " << my_map.bucket_count() << "\n";
+  std::cout << "my_map load_factor     = " << my_map.load_factor() << "\n";
+  std::cout << "my_map max_load_factor = " << my_map.max_load_factor() << "\n";
 
-  // Example with std::unordered_set
   std::unordered_set<int> my_set = {1, 2, 3, 4, 5};
 
-  std::cout << "Number of buckets in my_set: " << my_set.bucket_count()
-            << std::endl;
-  std::cout << "Current load factor in my_set: " << my_set.load_factor()
-            << std::endl;
-  std::cout << "Max load factor in my_set: " << my_set.max_load_factor()
-            << std::endl;
-
-  // Accessing the size of a specific bucket
-  size_t bucket_index = 0;
-  std::cout << "Elements in bucket " << bucket_index
-            << " of my_map: " << my_map.bucket_size(bucket_index) << std::endl;
+  std::cout << "my_set bucket_count    = " << my_set.bucket_count() << "\n";
+  std::cout << "my_set load_factor     = " << my_set.load_factor() << "\n";
+  std::cout << "my_set max_load_factor = " << my_set.max_load_factor() << "\n";
+
+  // Size of a specific bucket.
+  std::size_t bucket_index = 0;
+  std::cout << "my_map bucket_size(" << bucket_index
+            << ") = " << my_map.bucket_size(bucket_index) << "\n";
 }
 
 int main() {
-  unordered_mapCustomClasstype();
-  sizeOfTheHashTable();
+  builtinHash();
+  std::cout << "\n";
+  userDefinedHash();
+  std::cout << "\n";
+  bucketInterface();
 }

src/heap_and_stack_memory_layout_of_C_programs.cpp

@@ -1,4 +1,89 @@
-static int global_static = 1;
-int global_var = 1;
+// Memory layout demo: print the address of one variable from each segment
+// and observe where each lives in the process's virtual address space.
+//
+//   high address
+//      stack    (locals, grows down)
+//      heap     (new/malloc, grows up)
+//      .bss     (zero-initialized globals/statics)
+//      .data    (nonzero-initialized globals/statics)
+//      .rodata  (string literals, const tables)
+//      .text    (code)
+//   low address
 
-int main(void) { static int local_static = 1; }
+#include <cstdio>
+
+// .data : nonzero-initialized global
+int        global_initialized = 1;
+static int static_initialized = 1;
+
+// .bss  : zero-initialized global
+int        global_uninitialized;
+static int static_uninitialized;
+
+// .rodata : a const table the compiler can put in read-only memory
+const char rodata_string[] = "behnam";
+
+// .text : a function lives in code
+void some_function() {}
+
+void show_text_segment() {
+    printf("[.text]    address of some_function     : %p\n",
+           (void*)&some_function);
+}
+
+void show_rodata_segment() {
+    printf("[.rodata]  address of rodata_string     : %p\n",
+           (void*)rodata_string);
+}
+
+void show_data_segment() {
+    printf("[.data]    address of global_initialized: %p\n",
+           (void*)&global_initialized);
+    printf("[.data]    address of static_initialized: %p\n",
+           (void*)&static_initialized);
+}
+
+void show_bss_segment() {
+    printf("[.bss]     address of global_uninit     : %p\n",
+           (void*)&global_uninitialized);
+    printf("[.bss]     address of static_uninit     : %p\n",
+           (void*)&static_uninitialized);
+}
+
+void show_heap() {
+    int* p = new int(42);
+    printf("[heap]     address from new int         : %p\n", (void*)p);
+    delete p;
+}
+
+void show_stack() {
+    int local_a = 0;
+    int local_b = 0;
+    printf("[stack]    address of local_a           : %p\n", (void*)&local_a);
+    printf("[stack]    address of local_b           : %p\n", (void*)&local_b);
+    // On x86-64 the stack grows down, so &local_b is typically lower than &local_a.
+}
+
+int main() {
+    printf("=== .text  (code) ===\n");
+    show_text_segment();
+
+    printf("\n=== .rodata (read-only data) ===\n");
+    show_rodata_segment();
+
+    printf("\n=== .data  (initialized globals/statics) ===\n");
+    show_data_segment();
+
+    printf("\n=== .bss   (zero-initialized globals/statics) ===\n");
+    show_bss_segment();
+
+    printf("\n=== heap   (new / malloc) ===\n");
+    show_heap();
+
+    printf("\n=== stack  (locals) ===\n");
+    show_stack();
+
+    printf("\nExpected ordering (low -> high addresses):\n");
+    printf("  .text  <  .rodata  <  .data  <  .bss  <  heap  <<  stack\n");
+    return 0;
+}