feat: initial two notes of cppcon 2025 lectures (#17)

* feat: initial two notes of cppcon 2025 lectures

* fix ci check

Author: Charliechen114514

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/01-01-narrowing-demo.cpp

@@ -0,0 +1,12 @@
+#include <iostream>
+
+int main() {
+    int big = 30000;
+    short small = big;
+    short overflow = 40000;
+    double pi = 3.14159;
+    int int_pi = pi;
+    std::cout << "overflow = " << overflow << "\n";
+    std::cout << "int_pi = " << int_pi << "\n";
+    return 0;
+}

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/01-02-number-concept.cpp

@@ -0,0 +1,13 @@
+#include <concepts>
+#include <type_traits>
+#include <string>
+
+template<typename T>
+concept number = std::integral<T> || std::floating_point<T>;
+
+static_assert(number<int>, "int should be number");
+static_assert(number<double>, "double should be number");
+static_assert(number<char>, "char is integral, so number");
+static_assert(!number<std::string>, "string is not number");
+
+int main() { return 0; }

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/01-03-narrowing-concept.cpp

@@ -0,0 +1,31 @@
+#include <concepts>
+#include <type_traits>
+#include <limits>
+
+template<typename T>
+concept number = std::integral<T> || std::floating_point<T>;
+
+template<typename T, typename U>
+concept smaller_range =
+    number<T> && number<U> &&
+    (std::numeric_limits<T>::max() < std::numeric_limits<U>::max() ||
+     std::numeric_limits<T>::min() > std::numeric_limits<U>::min());
+
+template<typename T, typename U>
+concept narrowing_assign =
+    number<T> && number<U> &&
+    (
+        smaller_range<T, U> ||
+        (std::floating_point<U> && std::integral<T>) ||
+        (std::integral<T> && std::integral<U> &&
+         std::signed_integral<U> != std::signed_integral<T>)
+    );
+
+static_assert(narrowing_assign<short, int>, "int->short is narrowing");
+static_assert(narrowing_assign<int, double>, "double->int is narrowing");
+static_assert(narrowing_assign<unsigned int, int>, "int->unsigned may narrow");
+static_assert(!narrowing_assign<int, short>, "short->int is not narrowing");
+static_assert(!narrowing_assign<double, float>, "float->double is not narrowing");
+static_assert(!narrowing_assign<int, int>, "int->int is not narrowing");
+
+int main() { return 0; }

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/01-04-narrow-convert.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <type_traits>
+#include <limits>
+#include <stdexcept>
+
+template<typename T, typename U>
+constexpr bool would_narrow(U u) noexcept {
+    if constexpr (std::is_same_v<T, U>) {
+        return false;
+    } else if constexpr (std::is_floating_point_v<U> && std::is_integral_v<T>) {
+        // floating to integral, check at runtime
+    } else if constexpr (std::is_floating_point_v<T> && std::is_floating_point_v<U>) {
+        if constexpr (std::numeric_limits<T>::digits >= std::numeric_limits<U>::digits &&
+                      std::numeric_limits<T>::max() >= std::numeric_limits<U>::max() &&
+                      std::numeric_limits<T>::lowest() <= std::numeric_limits<U>::lowest()) {
+            return false;
+        }
+    } else if constexpr (std::is_integral_v<T> && std::is_integral_v<U>) {
+        if constexpr (std::is_signed_v<T> == std::is_signed_v<U>) {
+            if constexpr (std::numeric_limits<T>::max() >= std::numeric_limits<U>::max() &&
+                          std::numeric_limits<T>::lowest() <= std::numeric_limits<U>::lowest()) {
+                return false;
+            }
+        } else if constexpr (std::is_signed_v<T> && std::is_unsigned_v<U>) {
+            if constexpr (std::numeric_limits<T>::max() >= std::numeric_limits<U>::max()) {
+                return false;
+            }
+        }
+    }
+    // signed -> unsigned with negative source: always narrowing
+    // round-trip check can't catch this (int(-1) -> unsigned -> int(-1) is reversible on 2's complement)
+    if constexpr (std::is_unsigned_v<T> && std::is_signed_v<U>) {
+        if (u < 0) return true;
+    }
+    T t = static_cast<T>(u);
+    if (static_cast<U>(t) != u) {
+        return true;
+    }
+    if constexpr (std::is_floating_point_v<U> && std::is_integral_v<T>) {
+        if (u != static_cast<U>(static_cast<long long>(u))) {
+            return true;
+        }
+    }
+    return false;
+}
+
+template<typename T, typename U>
+constexpr T narrow_convert(U u) {
+    if (would_narrow<T>(u)) {
+        throw std::invalid_argument("narrowing conversion detected");
+    }
+    return static_cast<T>(u);
+}
+
+template<typename T>
+class Number {
+    T value_;
+public:
+    template<typename U>
+    constexpr Number(U u) : value_(narrow_convert<T>(u)) {}
+    constexpr Number(T t) : value_(t) {}
+    constexpr operator T() const noexcept { return value_; }
+    constexpr T get() const noexcept { return value_; }
+};
+
+int main() {
+    int a = narrow_convert<int>(42.0);
+    unsigned int b = narrow_convert<unsigned int>(100);
+    std::cout << "a = " << a << ", b = " << b << "\n";
+
+    try { char c = narrow_convert<char>(300); }
+    catch (const std::invalid_argument& e) { std::cout << "caught: " << e.what() << "\n"; }
+
+    try { unsigned int d = narrow_convert<unsigned int>(-1); }
+    catch (const std::invalid_argument& e) { std::cout << "caught: " << e.what() << "\n"; }
+
+    Number<int> x = 42;
+    Number<int> y = 3.0;
+    std::cout << "x = " << x << ", y = " << y << "\n";
+
+    try { Number<char> c = 300; }
+    catch (const std::invalid_argument& e) { std::cout << "caught: " << e.what() << "\n"; }
+
+    return 0;
+}

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/01-05-number-arithmetic.cpp

@@ -0,0 +1,84 @@
+#include <iostream>
+#include <type_traits>
+#include <limits>
+#include <stdexcept>
+
+template<typename T, typename U>
+constexpr bool would_narrow(U u) noexcept {
+    if constexpr (std::is_same_v<T, U>) { return false; }
+    else if constexpr (std::is_floating_point_v<U> && std::is_integral_v<T>) { }
+    else if constexpr (std::is_floating_point_v<T> && std::is_floating_point_v<U>) {
+        if constexpr (std::numeric_limits<T>::digits >= std::numeric_limits<U>::digits &&
+                      std::numeric_limits<T>::max() >= std::numeric_limits<U>::max() &&
+                      std::numeric_limits<T>::lowest() <= std::numeric_limits<U>::lowest()) {
+            return false;
+        }
+    } else if constexpr (std::is_integral_v<T> && std::is_integral_v<U>) {
+        if constexpr (std::is_signed_v<T> == std::is_signed_v<U>) {
+            if constexpr (std::numeric_limits<T>::max() >= std::numeric_limits<U>::max() &&
+                          std::numeric_limits<T>::lowest() <= std::numeric_limits<U>::lowest()) { return false; }
+        } else if constexpr (std::is_signed_v<T> && std::is_unsigned_v<U>) {
+            if constexpr (std::numeric_limits<T>::max() >= std::numeric_limits<U>::max()) { return false; }
+        }
+    }
+    // signed -> unsigned with negative source: always narrowing
+    if constexpr (std::is_unsigned_v<T> && std::is_signed_v<U>) {
+        if (u < 0) return true;
+    }
+    T t = static_cast<T>(u);
+    if (static_cast<U>(t) != u) { return true; }
+    if constexpr (std::is_floating_point_v<U> && std::is_integral_v<T>) {
+        if (u != static_cast<U>(static_cast<long long>(u))) { return true; }
+    }
+    return false;
+}
+
+template<typename T, typename U>
+constexpr T narrow_convert(U u) {
+    if (would_narrow<T>(u)) throw std::invalid_argument("narrowing conversion detected");
+    return static_cast<T>(u);
+}
+
+template<typename T>
+class Number {
+    T value_;
+public:
+    template<typename U> constexpr Number(U u) : value_(narrow_convert<T>(u)) {}
+    constexpr Number(T t) : value_(t) {}
+    constexpr operator T() const noexcept { return value_; }
+    constexpr T get() const noexcept { return value_; }
+    template<typename U>
+    constexpr auto operator+(const Number<U>& other) const -> Number<std::common_type_t<T, U>> {
+        using R = std::common_type_t<T, U>;
+        return Number<R>(value_ + other.get());
+    }
+    template<typename U>
+    constexpr auto operator-(const Number<U>& other) const -> Number<std::common_type_t<T, U>> {
+        using R = std::common_type_t<T, U>;
+        return Number<R>(value_ - other.get());
+    }
+    template<typename U>
+    constexpr auto operator*(const Number<U>& other) const -> Number<std::common_type_t<T, U>> {
+        using R = std::common_type_t<T, U>;
+        return Number<R>(value_ * other.get());
+    }
+};
+
+int main() {
+    Number<int> a = 10;
+    Number<double> b = 3.5;
+    auto result = a + b;
+    std::cout << "10 + 3.5 = " << result << "\n";
+    std::cout << "result type is Number<double>? "
+              << std::is_same_v<decltype(result), Number<double>> << "\n";
+
+    Number<unsigned int> x = 3000000000u;
+    Number<unsigned int> y = 2000000000u;
+    // NOTE: unsigned arithmetic wraps before narrow_convert can check.
+    // This does NOT throw — the result is 705032704 (a valid unsigned int).
+    // See 01-06-overflow-not-caught.cpp for the full demonstration.
+    auto wrapped = x + y;
+    std::cout << "3000000000u + 2000000000u = " << wrapped
+              << " (wrapped, no exception)\n";
+    return 0;
+}

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/01-06-overflow-not-caught.cpp

@@ -0,0 +1,102 @@
+/*
+ * 验证：Number<T> 的算术溢出检测在 unsigned 类型上的局限
+ *
+ * 背景：文章原稿声称 Number<unsigned int>(3000000000u) + Number<unsigned int>(2000000000u)
+ *       会抛出 std::invalid_argument 异常。但 unsigned 算术是 well-defined wrapping，
+ *       结果在传给 narrow_convert 之前就已经回绕为合法值。
+ *
+ * 预期结果：不会抛异常，输出回绕后的值 705032704
+ *
+ * 编译命令：
+ *   g++ -std=c++20 -o /tmp/overflow-not-caught 01-06-overflow-not-caught.cpp
+ *
+ * 运行：
+ *   /tmp/overflow-not-caught
+ *
+ * 编译器：GCC 16.1.1
+ */
+
+#include <iostream>
+#include <type_traits>
+#include <limits>
+#include <stdexcept>
+
+template<typename T, typename U>
+constexpr bool would_narrow(U u) noexcept {
+    if constexpr (std::is_same_v<T, U>) { return false; }
+    else if constexpr (std::is_floating_point_v<U> && std::is_integral_v<T>) { }
+    else if constexpr (std::is_floating_point_v<T> && std::is_floating_point_v<U>) {
+        if constexpr (std::numeric_limits<T>::digits >= std::numeric_limits<U>::digits &&
+                      std::numeric_limits<T>::max() >= std::numeric_limits<U>::max() &&
+                      std::numeric_limits<T>::lowest() <= std::numeric_limits<U>::lowest()) {
+            return false;
+        }
+    } else if constexpr (std::is_integral_v<T> && std::is_integral_v<U>) {
+        if constexpr (std::is_signed_v<T> == std::is_signed_v<U>) {
+            if constexpr (std::numeric_limits<T>::max() >= std::numeric_limits<U>::max() &&
+                          std::numeric_limits<T>::lowest() <= std::numeric_limits<U>::lowest()) { return false; }
+        } else if constexpr (std::is_signed_v<T> && std::is_unsigned_v<U>) {
+            if constexpr (std::numeric_limits<T>::max() >= std::numeric_limits<U>::max()) { return false; }
+        }
+    }
+    // signed -> unsigned with negative source: always narrowing
+    if constexpr (std::is_unsigned_v<T> && std::is_signed_v<U>) {
+        if (u < 0) return true;
+    }
+    T t = static_cast<T>(u);
+    if (static_cast<U>(t) != u) { return true; }
+    if constexpr (std::is_floating_point_v<U> && std::is_integral_v<T>) {
+        if (u != static_cast<U>(static_cast<long long>(u))) { return true; }
+    }
+    return false;
+}
+
+template<typename T, typename U>
+constexpr T narrow_convert(U u) {
+    if (would_narrow<T>(u)) throw std::invalid_argument("narrowing conversion detected");
+    return static_cast<T>(u);
+}
+
+template<typename T>
+class Number {
+    T value_;
+public:
+    template<typename U> constexpr Number(U u) : value_(narrow_convert<T>(u)) {}
+    constexpr Number(T t) : value_(t) {}
+    constexpr operator T() const noexcept { return value_; }
+    constexpr T get() const noexcept { return value_; }
+    template<typename U>
+    constexpr auto operator+(const Number<U>& other) const -> Number<std::common_type_t<T, U>> {
+        using R = std::common_type_t<T, U>;
+        return Number<R>(value_ + other.get());
+    }
+};
+
+int main() {
+    // unsigned 溢出测试：文章声称会抛异常
+    Number<unsigned int> x = 3000000000u;
+    Number<unsigned int> y = 2000000000u;
+
+    // 先看原始 unsigned 算术
+    unsigned int raw_sum = 3000000000u + 2000000000u;
+    std::cout << "Raw unsigned sum: " << raw_sum << "\n";
+    std::cout << "Would narrow (same type)? " << would_narrow<unsigned int>(raw_sum) << "\n";
+
+    // 实际测试：不会抛异常
+    try {
+        auto overflow = x + y;
+        std::cout << "No exception thrown! overflow = " << overflow << "\n";
+    } catch (const std::invalid_argument& e) {
+        std::cout << "Exception caught: " << e.what() << "\n";
+    }
+
+    // 对比：真正的窄化转换确实能被捕获
+    try {
+        Number<short> s = narrow_convert<short>(40000);
+        std::cout << "short = " << s << "\n";
+    } catch (const std::invalid_argument& e) {
+        std::cout << "Narrowing correctly caught: " << e.what() << "\n";
+    }
+
+    return 0;
+}

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/02-01-safe-int-operators.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <functional>
+
+template <typename T>
+struct safe_int {
+    T value;
+    friend safe_int operator+(const safe_int& a, const safe_int& b) {
+        return safe_int{std::plus<T>{}(a.value, b.value)};
+    }
+    friend safe_int operator*(const safe_int& a, const safe_int& b) {
+        return safe_int{std::multiplies<T>{}(a.value, b.value)};
+    }
+};
+
+int main() {
+    safe_int<int> a{10}, b{20};
+    auto c = a + b;
+    auto d = a * b;
+    std::cout << "10 + 20 = " << c.value << "\n";
+    std::cout << "10 * 20 = " << d.value << "\n";
+    return 0;
+}

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/02-02-comparison-trap.cpp

@@ -0,0 +1,8 @@
+#include <iostream>
+
+int main() {
+    int a = -1;
+    unsigned int b = 2;
+    std::cout << "(a < b) = " << (a < b) << "\n";  // prints 0 (false!) due to unsigned conversion
+    return 0;
+}

code/volumn_codes/vol10/cppcon/2025/01-concept-based-generic-programming/02-03-safe-comparison.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <type_traits>
+
+template <typename T>
+struct safe_int {
+    T value;
+};
+
+template <typename T, typename U>
+bool operator<(const safe_int<T>& a, const safe_int<U>& b) {
+    if constexpr (std::is_signed_v<T> && std::is_unsigned_v<U>) {
+        if (a.value < 0) return true;
+        return static_cast<std::make_unsigned_t<T>>(a.value) < b.value;
+    } else if constexpr (std::is_unsigned_v<T> && std::is_signed_v<U>) {
+        if (b.value < 0) return false;
+        return a.value < static_cast<std::make_unsigned_t<U>>(b.value);
+    } else {
+        return a.value < b.value;
+    }
+}
+
+int main() {
+    safe_int<int> a{-1};
+    safe_int<unsigned int> b{2};
+    std::cout << "(a < b) = " << (a < b) << "\n";  // Now correctly prints 1 (true)
+    return 0;
+}