Add notes on std::any and reference wrapper

Author: XuhuaHuang

Miscellaneous/CMakeLists.txt

@@ -2,15 +2,18 @@ cmake_minimum_required(VERSION 3.20)
 
 project("misc" LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     # Compiler is Microsoft Visual C++
     # Set MSVC-specific flags
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /Zc:__cplusplus /EHsc /std:c++latest /experimental:module")
+
+    add_executable(winapi_cmdarg "winapi_cmdarg.cpp")
+    add_executable(multiple_of "is_multiple_of.cpp")
 endif()
 
-add_executable(multiple_of "is_multiple_of.cpp")
 add_executable(unions_align "unions_align.cpp")
-add_executable(winapi_cmdarg "winapi_cmdarg.cpp")
+add_executable(std_any "use_std_any.cpp")
+add_executable(std_make_any "use_std_make_any.cpp")

Miscellaneous/use_format.cpp

@@ -8,19 +8,19 @@
 
 template <typename... Args>
 std::string dyna_print(std::string_view rt_fmt_str, Args&&... args) {
-    return std::vformat(rt_fmt_str, std::make_format_args(args...));
+  return std::vformat(rt_fmt_str, std::make_format_args(args...));
 }
 
 int main() {
-    std::cout << std::format("Hello {}!\n", "world");
+  std::cout << std::format("Hello {}!\n", "world");
 
-    std::string fmt;
-    for (int i{}; i != 3; ++i) {
-        fmt += "{} "; // constructs the formatting string
-        std::cout << fmt << " : ";
-        std::cout << dyna_print(fmt, "alpha", 'Z', 3.14, "unused");
-        std::cout << '\n';
-    }
+  std::string fmt;
+  for (int i{}; i != 3; ++i) {
+    fmt += "{} "; // constructs the formatting string
+    std::cout << fmt << " : ";
+    std::cout << dyna_print(fmt, "alpha", 'Z', 3.14, "unused");
+    std::cout << '\n';
+  }
 
-    return 0;
+  return 0;
 }

Miscellaneous/use_std_any.cpp

@@ -0,0 +1,50 @@
+/**
+ * @file use_std_any.cpp
+ * @author Xuhua Huang
+ * @brief
+ * @version 0.1
+ * @date 2026-01-18
+ *
+ * @copyright Copyright (c) 2026
+ *
+ */
+
+#include <any>
+#include <iostream>
+
+int main() {
+  std::cout << std::boolalpha;
+
+  // any type
+  std::any a = 1;
+  std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\n';
+  a = 3.14;
+  std::cout << a.type().name() << ": " << std::any_cast<double>(a) << '\n';
+  a = true;
+  std::cout << a.type().name() << ": " << std::any_cast<bool>(a) << '\n';
+
+  // bad cast
+  try {
+    a = 1;
+    std::cout << std::any_cast<float>(a) << '\n';
+  } catch (const std::bad_any_cast& e) {
+    std::cout << e.what() << '\n';
+  }
+
+  // has value
+  a = 2;
+  if (a.has_value())
+    std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\n';
+
+  // reset
+  a.reset();
+  if (!a.has_value())
+    std::cout << "no value\n";
+
+  // pointer to contained data
+  a      = 3;
+  int* i = std::any_cast<int>(&a);
+  std::cout << *i << '\n';
+
+  return 0;
+}

Miscellaneous/use_std_make_any.cpp

@@ -0,0 +1,46 @@
+/**
+ * @file use_std_make_any.cpp
+ * @author Xuhua Huang
+ * @brief
+ * @version 0.1
+ * @date 2026-01-18
+ *
+ * @copyright Copyright (c) 2026
+ *
+ */
+
+#include <any>
+#include <complex>
+#include <functional>
+#include <iostream>
+#include <string>
+
+int main() {
+  auto a0 = std::make_any<std::string>("Hello, std::any!\n");
+  auto a1 = std::make_any<std::complex<double>>(0.1, 2.3);
+
+  std::cout << std::any_cast<std::string&>(a0);
+  std::cout << std::any_cast<std::complex<double>&>(a1) << '\n';
+
+  using lambda = std::function<void(void)>;
+
+  // Put a lambda into std::any. Attempt #1 (failed).
+  std::any a2 = [] { std::cout << "Lambda #1.\n"; };
+  std::cout << "a2.type() = \"" << a2.type().name() << "\"\n";
+
+  // any_cast casts to <void(void)> but actual type is not
+  // a std::function..., but ~ main::{lambda()#1}, and it is
+  // unique for each lambda. So, this throws...
+  try {
+    std::any_cast<lambda>(a2)();
+  } catch (const std::bad_any_cast& ex) {
+    std::cout << ex.what() << '\n';
+  }
+
+  // Put a lambda into std::any. Attempt #2 (successful).
+  auto a3 = std::make_any<lambda>([] { std::cout << "Lambda #2.\n"; });
+  std::cout << "a3.type() = \"" << a3.type().name() << "\"\n";
+  std::any_cast<lambda>(a3)();
+
+  return 0;
+}

RawPointer/void_ptr.cpp

@@ -13,6 +13,19 @@
 #include <cstdlib>
 #include <iostream>
 
+/**
+ * @brief C++ allows pointers without a specific data type associated with them
+ * These pointers are referred to as void pointers
+ * Void pointers are frequently used in C to create generic methods as
+ * they are not tied to particular data types
+ *
+ * @note Void pointers cannot be dereferenced
+ * They need to be explicitly cast to another pointer type before dereferencing
+ * Pointer arithmetic are not allowed on void pointers
+ * Some compilers permit pointer arithmetic with void pointers, however, assuming
+ * the size of void is 1 and so you are essentially working with a block of byte data
+ *
+ */
 int main() {
   std::nullptr_t np = nullptr;
   void*          vp = nullptr;

Reference/CMakeLists.txt

@@ -11,16 +11,17 @@ set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 # Set any necessary compile flags
-if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     # Compiler is Microsoft Visual C++
     # Set MSVC-specific flags
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /Zc:__cplusplus /EHsc /std:c17 /std:c++latest /experimental:module")
 endif()
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     # Compiler is g++
     # Set g++-specific flags
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
 endif()
 
 add_executable(ref "ref.cpp")
+add_executable(ref_wrapper "ref_wrapper.cpp")

Reference/ref_wrapper.cpp

@@ -0,0 +1,46 @@
+/**
+ * @file ref_wrapper.cpp
+ * @author Xuhua Huang
+ * @brief
+ * @version 0.1
+ * @date 2026-01-18
+ *
+ * @copyright Copyright (c) 2026
+ *
+ */
+
+#include <concepts>
+#include <functional>
+#include <iostream>
+#include <list>
+#include <numeric>
+#include <random>
+#include <ranges>
+#include <vector>
+
+void println(const auto rem, const std::ranges::range auto& v) {
+  for (std::cout << rem; const auto& e : v)
+    std::cout << e << ' ';
+  std::cout << '\n';
+}
+
+int main() {
+  std::list<int> l(10);
+  std::iota(l.begin(), l.end(), -4);
+
+  // can't use shuffle on a list (requires random access), but can use it on a vector
+  std::vector<std::reference_wrapper<int>> v(l.begin(), l.end());
+
+  // std::ranges::shuffle(v, std::mt19937{std::random_device{}()});
+  std::shuffle(v.begin(), v.end(), std::mt19937{std::random_device{}()});
+  println("Contents of the list: ", l);
+  println("Contents of the list, as seen through a shuffled vector: ", v);
+
+  std::cout << "Doubling the values in the initial list...\n";
+  // std::ranges::for_each(l, [](int& i) { i *= 2; });
+  std::for_each(l.begin(), l.end(), [](int& i) -> void { i *= 2; });
+
+  println("Contents of the list, as seen through a shuffled vector: ", v);
+
+  return 0;
+}

View/views_notes.cpp

@@ -24,7 +24,7 @@ std::vector<int> generate_values(int start, int end) {
 }
 
 [[nodiscard]] [[gnu::always_inline]]
-auto get_data() -> std::vector<int> {
+inline auto get_data() -> std::vector<int> {
   return generate_values(2, 13);
 }