Great question—handling numeric conversions safely is absolutely critical in applied math, signal processing, and algorithm code, where even tiny precision losses or overflow can wreck results. Let’s break down your options for standard C++ equivalents to boost::numeric_cast:

C++23: std::numeric_cast (The Direct Equivalent) #

If you’re able to use C++23 or later, you’re in luck: the standard library now includes std::numeric_cast, which is designed to match the behavior of boost::numeric_cast almost exactly. It performs runtime checks for:

• Overflow/underflow: When the source value exceeds the minimum or maximum representable value of the destination type (e.g., a double larger than INT32_MAX being cast to int32_t).
• Precision loss: When casting from a floating-point type to an integer type, it checks if the source value has a non-integer fractional part that would be truncated.

On failure, it throws a std::range_error exception. There’s also a non-throwing variant (std::numeric_cast_if) that returns a std::optional<DestType> or an error code, depending on how you use it.

Example usage:

#include <numeric> // For std::numeric_cast
#include <cstdint>

double large_value = 3e9;
try {
    int32_t converted = std::numeric_cast<int32_t>(large_value);
} catch (const std::range_error& e) {
    // Handle overflow error
}

Pre-C++23: Roll Your Own Safe Cast Function #

If you’re stuck on an older C++ standard, you can easily replicate the core behavior of boost::numeric_cast with a custom template function. This lets you enforce the same overflow, underflow, and truncation checks at runtime.

Here’s a robust example:

#include <stdexcept>
#include <limits>
#include <cmath>
#include <type_traits>

template <typename DestType, typename SourceType>
DestType safe_numeric_cast(SourceType value) {
    // Check for overflow: source exceeds max of destination
    if (value > static_cast<SourceType>(std::numeric_limits<DestType>::max())) {
        throw std::overflow_error("Value exceeds maximum representable value of destination type");
    }
    // Check for underflow: source is below min of destination
    if (value < static_cast<SourceType>(std::numeric_limits<DestType>::min())) {
        throw std::underflow_error("Value is below minimum representable value of destination type");
    }
    // Check for truncation when casting float/double to integer types
    if constexpr (std::is_integral_v<DestType> && std::is_floating_point_v<SourceType>) {
        if (std::trunc(value) != value) {
            throw std::domain_error("Floating-point value has non-integer fractional part");
        }
    }
    // If all checks pass, perform the cast
    return static_cast<DestType>(value);
}

You can use this just like boost::numeric_cast:

double pi = 3.14159;
try {
    int32_t pi_int = safe_numeric_cast<int32_t>(pi); // Throws domain_error due to fractional part
} catch (const std::domain_error& e) {
    // Handle truncation error
}

Honorable Mention: std::clamp (For Clamping Instead of Erroring) #

If your use case prefers clamping values to the valid range of the destination type instead of throwing exceptions, C++17 introduced std::clamp. This will restrict the source value to the min/max of the destination type, but note that it does not check for fractional part truncation—you’ll need to add that manually if needed.

Example:

#include <algorithm> // For std::clamp
#include <cstdint>

double noisy_value = 2.7e9;
// Clamp to int32_t range, then cast
int32_t clamped = static_cast<int32_t>(std::clamp(noisy_value, 
    static_cast<double>(INT32_MIN), 
    static_cast<double>(INT32_MAX)));

Final Notes #

Your -Wconversion compiler warning is a great compile-time safety net, but it can’t catch all runtime edge cases (like values that are only out of bounds during execution). boost::numeric_cast (or its standard equivalents) fills that gap by adding runtime validation.

内容的提问来源于stack exchange，提问作者Trevor Boyd Smith