Why Does C Exclude Undefined Behavior from Constant Expressions?

Why Constant Expressions Exclude Undefined Behavior

In C , constant expressions are mathematical expressions that are evaluated at compile time. While evaluating these expressions, it's essential to handle cases where undefined behavior (UB) might occur.

The Exclusion Clause

The C standard, in section 5.19, explicitly states an exclusion for undefined behavior in a core constant expression:

"...an operation that would have undefined behavior [...] is not considered."

Purpose of the Exclusion

This exclusion clause serves two primary purposes:

1. Error Detection at Compile Time: By excluding UB, the compiler can identify and report errors related to UB at compile time rather than runtime. This allows early detection and correction of potential issues.
2. Facilitating Compile-Time Tools: The exclusion enables the creation of tools and techniques that can leverage constant expressions in a reliable manner. For example, metaprogramming libraries can use constant expressions to perform compile-time calculations without introducing undefined behavior.

Example and Advantages

Consider the following expression:

constexpr int x = std::numeric_limits<int>::max() + 1;

Without the exclusion clause, this expression would be considered a constant expression because it doesn't involve any of the explicitly excluded operations. However, it would still exhibit UB due to integer overflow.

The exclusion clause allows the compiler to detect this UB at compile time, as demonstrated below:

error: constexpr variable 'x' must be initialized by a constant expression
    constexpr int x = std::numeric_limits<int>::max() + 1 ;

SFINAE Usage

The exclusion clause also enables the use of constant expressions in SFINAE (Substitution Failure Is Not An Error) to determine whether an expression would cause UB at compile time. For example, the following code snippet illustrates how to detect integer addition overflow:

template <typename T1, typename T2>
struct addIsDefined
{
    static constexpr bool isDefined()
    {
        return isDefinedHelper<T1, T2>(0);
    }

    template <T1 t1, T2 t2, decltype(t1 + t2) result = t1 + t2>
    static constexpr bool isDefinedHelper(int)
    {
        return true;
    }

    template <T1 t1, T2 t2>
    static constexpr bool isDefinedHelper(...)
    {
        return false;
    }
};

In summary, the presence of an exclusion clause for undefined behavior in constant expressions allows the compiler to detect UB at compile time, facilitating the development of safer, more reliable code.

The above is the detailed content of Why Does C Exclude Undefined Behavior from Constant Expressions?. For more information, please follow other related articles on the PHP Chinese website!