Update examples with new literal types

Author: mborland

doc/modules/ROOT/pages/literals.adoc

@@ -143,7 +143,7 @@ The same asymmetry applies to `_i16`, `_i32`, `_i64`, and `_i128`.
 
 == Examples
 
-.This https://github.com/boostorg/safe_numbers/blob/develop/examples/literals.cpp[example] demonstrates how to use user-defined literals with safe integer types.
+.This https://github.com/boostorg/safe_numbers/blob/develop/examples/literals.cpp[example] demonstrates how to use user-defined literals with safe numeric types.
 ====
 [source, c++]
 ----
@@ -157,6 +157,13 @@ Output:
 100000_u32 = 100000
 9999999999_u64 = 9999999999
 max_u128 = 340282366920938463463374607431768211455
+-42_i8  = -42
+max_i16 = 32767
+min+1_i32 = -2147483647
+max_i64 = 9223372036854775807
+min+1_i128 = -170141183460469231731687303715884105727
+pi_f32 = 3.14
+e_f64  = 2.71828
 100_u32 + 50_u32 = 150
 6_u32 * 7_u32    = 42
 constexpr 255_u8 = 255

examples/literals.cpp

@@ -3,10 +3,12 @@
 // https://www.boost.org/LICENSE_1_0.txt
 
 // This example demonstrates the use of user-defined literals for
-// constructing safe integer types. The literals provide a concise
+// constructing safe numeric types. The literals provide a concise
 // syntax and perform compile-time range checking when possible.
 
 #include <boost/safe_numbers/unsigned_integers.hpp>
+#include <boost/safe_numbers/signed_integers.hpp>
+#include <boost/safe_numbers/floats.hpp>
 #include <boost/safe_numbers/literals.hpp>
 #include <boost/safe_numbers/iostream.hpp>
 #include <iostream>
@@ -16,7 +18,7 @@ int main()
     using namespace boost::safe_numbers;
     using namespace boost::safe_numbers::literals;
 
-    // Construct safe integers using literal suffixes
+    // Construct safe unsigned integers using literal suffixes
     {
         constexpr auto a {42_u8};
         constexpr auto b {1000_u16};
@@ -31,6 +33,32 @@ int main()
         std::cout << "max_u128 = " << e << std::endl;
     }
 
+    // Signed integer literals. Negative values are formed by applying unary
+    // minus to a positive literal: -42_i32 parses as -(42_i32).
+    {
+        constexpr auto a {-42_i8};
+        constexpr auto b {32767_i16};
+        constexpr auto c {-2147483647_i32};
+        constexpr auto d {9223372036854775807_i64};
+        constexpr auto e {-170141183460469231731687303715884105727_i128};
+
+        std::cout << "-42_i8  = " << a << std::endl;
+        std::cout << "max_i16 = " << b << std::endl;
+        std::cout << "min+1_i32 = " << c << std::endl;
+        std::cout << "max_i64 = " << d << std::endl;
+        std::cout << "min+1_i128 = " << e << std::endl;
+    }
+
+    // Floating-point literals. The literal accepts a long double and is
+    // range-checked against the target type's maximum.
+    {
+        constexpr auto pi {3.14_f32};
+        constexpr auto e {2.718281828459045_f64};
+
+        std::cout << "pi_f32 = " << pi << std::endl;
+        std::cout << "e_f64  = " << e << std::endl;
+    }
+
     // Literals work naturally in expressions
     {
         const auto sum {100_u32 + 50_u32};
@@ -56,6 +84,8 @@ int main()
     //
     //   auto bad = 256_u8;    // throws std::overflow_error (> UINT8_MAX)
     //   auto bad = 70000_u16; // throws std::overflow_error (> UINT16_MAX)
+    //   auto bad = 128_i8;    // throws std::overflow_error (> INT8_MAX)
+    //   auto bad = 1.0e40_f32; // throws std::overflow_error (> FLT_MAX)
 
     return 0;
 }