Avoid copies and improve readability

Author: mborland

include/boost/decimal/decimal64.hpp

@@ -1219,15 +1219,16 @@ constexpr auto operator+(decimal64 lhs, decimal64 rhs) noexcept -> decimal64
     auto rhs_exp {rhs.biased_exponent()};
     detail::normalize<decimal64>(rhs_sig, rhs_exp);
 
-    return {detail::d64_add_impl<decimal64>(lhs_sig, lhs_exp, lhs.isneg(),
-                                            rhs_sig, rhs_exp, rhs.isneg())};
+    return detail::d64_add_impl<decimal64>(lhs_sig, lhs_exp, lhs.isneg(),
+                                           rhs_sig, rhs_exp, rhs.isneg());
 }
 
 template <typename Integer>
 constexpr auto operator+(decimal64 lhs, Integer rhs) noexcept
     BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal64)
 {
     using promoted_significand_type = detail::promote_significand_t<decimal64, Integer>;
+    using exp_type = decimal64::biased_exponent_type;
 
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (isnan(lhs) || isinf(lhs))
@@ -1250,7 +1251,7 @@ constexpr auto operator+(decimal64 lhs, Integer rhs) noexcept
     detail::normalize<decimal64>(sig_lhs, exp_lhs);
     auto lhs_components {detail::decimal64_components{sig_lhs, exp_lhs, lhs.isneg()}};
 
-    decimal64::biased_exponent_type exp_rhs {0};
+    exp_type exp_rhs {0};
     detail::normalize<decimal64>(sig_rhs, exp_rhs);
     const auto final_sig_rhs {static_cast<detail::decimal64_components::significand_type>(sig_rhs)};
     auto rhs_components {detail::decimal64_components{final_sig_rhs, exp_rhs, (rhs < 0)}};
@@ -1316,16 +1317,17 @@ constexpr auto operator-(decimal64 lhs, decimal64 rhs) noexcept -> decimal64
     auto exp_rhs {rhs.biased_exponent()};
     detail::normalize<decimal64>(sig_rhs, exp_rhs);
 
-    return {detail::d64_sub_impl<decimal64>(sig_lhs, exp_lhs, lhs.isneg(),
-                                            sig_rhs, exp_rhs, rhs.isneg(),
-                                            abs_lhs_bigger)};
+    return detail::d64_sub_impl<decimal64>(sig_lhs, exp_lhs, lhs.isneg(),
+                                           sig_rhs, exp_rhs, rhs.isneg(),
+                                           abs_lhs_bigger);
 }
 
 template <typename Integer>
 constexpr auto operator-(decimal64 lhs, Integer rhs) noexcept
     BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal64)
 {
     using promoted_significand_type = detail::promote_significand_t<decimal64, Integer>;
+    using exp_type = decimal64::biased_exponent_type;
 
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (isinf(lhs) || isnan(lhs))
@@ -1346,20 +1348,21 @@ constexpr auto operator-(decimal64 lhs, Integer rhs) noexcept
     auto exp_lhs {lhs.biased_exponent()};
     detail::normalize<decimal64>(sig_lhs, exp_lhs);
 
-    decimal64::biased_exponent_type exp_rhs {0};
+    exp_type exp_rhs {0};
     detail::normalize<decimal64>(sig_rhs, exp_rhs);
     const auto final_sig_rhs {static_cast<decimal64::significand_type>(sig_rhs)};
 
-    return {detail::d64_sub_impl<decimal64>(sig_lhs, exp_lhs, lhs.isneg(),
-                                            final_sig_rhs, exp_rhs, (rhs < 0),
-                                            abs_lhs_bigger)};
+    return detail::d64_sub_impl<decimal64>(sig_lhs, exp_lhs, lhs.isneg(),
+                                           final_sig_rhs, exp_rhs, (rhs < 0),
+                                           abs_lhs_bigger);
 }
 
 template <typename Integer>
 constexpr auto operator-(Integer lhs, decimal64 rhs) noexcept
     BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal64)
 {
     using promoted_significand_type = detail::promote_significand_t<decimal64, Integer>;
+    using exp_type = decimal64::biased_exponent_type;
 
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (isinf(rhs) || isnan(rhs))
@@ -1376,17 +1379,17 @@ constexpr auto operator-(Integer lhs, decimal64 rhs) noexcept
     auto sig_lhs {static_cast<promoted_significand_type>(detail::make_positive_unsigned(lhs))};
     const bool abs_lhs_bigger {sig_lhs > abs(rhs)};
 
-    decimal64::biased_exponent_type exp_lhs {0};
+    exp_type exp_lhs {0};
     detail::normalize<decimal64>(sig_lhs, exp_lhs);
     const auto final_sig_lhs {static_cast<decimal64::significand_type>(detail::make_positive_unsigned(sig_lhs))};
 
     auto sig_rhs {rhs.full_significand()};
     auto exp_rhs {rhs.biased_exponent()};
     detail::normalize<decimal64>(sig_rhs, exp_rhs);
 
-    return {detail::d64_sub_impl<decimal64>(final_sig_lhs, exp_lhs, (lhs < 0),
-                                            sig_rhs, exp_rhs, rhs.isneg(),
-                                            abs_lhs_bigger)};
+    return detail::d64_sub_impl<decimal64>(final_sig_lhs, exp_lhs, (lhs < 0),
+                                           sig_rhs, exp_rhs, rhs.isneg(),
+                                           abs_lhs_bigger);
 }
 
 constexpr auto operator*(decimal64 lhs, decimal64 rhs) noexcept -> decimal64
@@ -1409,15 +1412,16 @@ constexpr auto operator*(decimal64 lhs, decimal64 rhs) noexcept -> decimal64
     auto rhs_exp {rhs.biased_exponent()};
     detail::normalize<decimal64>(rhs_sig, rhs_exp);
 
-    return {detail::d64_mul_impl<decimal64>(lhs_sig, lhs_exp, lhs.isneg(),
-                                            rhs_sig, rhs_exp, rhs.isneg())};
+    return detail::d64_mul_impl<decimal64>(lhs_sig, lhs_exp, lhs.isneg(),
+                                           rhs_sig, rhs_exp, rhs.isneg());
 }
 
 template <typename Integer>
 constexpr auto operator*(decimal64 lhs, Integer rhs) noexcept
     BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal64)
 {
     using promoted_significand_type = detail::promote_significand_t<decimal64, Integer>;
+    using exp_type = decimal64::biased_exponent_type;
 
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (isnan(lhs) || isinf(lhs))
@@ -1431,12 +1435,12 @@ constexpr auto operator*(decimal64 lhs, Integer rhs) noexcept
     detail::normalize<decimal64>(lhs_sig, lhs_exp);
 
     auto rhs_sig {static_cast<promoted_significand_type>(detail::make_positive_unsigned(rhs))};
-    decimal64::biased_exponent_type rhs_exp {0};
+    exp_type rhs_exp {0};
     detail::normalize<decimal64>(rhs_sig, rhs_exp);
     const auto final_rhs_sig {static_cast<decimal64::significand_type>(rhs_sig)};
 
-    return {detail::d64_mul_impl<decimal64>(lhs_sig, lhs_exp, lhs.isneg(),
-                                            final_rhs_sig, rhs_exp, (rhs < 0))};
+    return detail::d64_mul_impl<decimal64>(lhs_sig, lhs_exp, lhs.isneg(),
+                                           final_rhs_sig, rhs_exp, (rhs < 0));
 }
 
 template <typename Integer>
@@ -1459,6 +1463,8 @@ template <typename Integer>
 constexpr auto operator/(decimal64 lhs, Integer rhs) noexcept
     BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal64)
 {
+    using exp_type = decimal64::biased_exponent_type;
+
     #ifndef BOOST_DECIMAL_FAST_MATH
     // Check pre-conditions
     constexpr decimal64 zero {0, 0};
@@ -1494,7 +1500,7 @@ constexpr auto operator/(decimal64 lhs, Integer rhs) noexcept
     detail::decimal64_components lhs_components {lhs_sig, lhs_exp, lhs.isneg()};
 
     auto rhs_sig {static_cast<std::uint64_t>(detail::make_positive_unsigned(rhs))};
-    std::int32_t rhs_exp {};
+    exp_type rhs_exp {};
     detail::decimal64_components rhs_components {detail::shrink_significand<std::uint64_t>(rhs_sig, rhs_exp), rhs_exp, rhs < 0};
 
     return detail::d64_generic_div_impl<decimal64>(lhs_components, rhs_components);