为何同一约束需推导不同类型时，概念作类型说明符会导致推导失败？

Let’s unpack why your foo2 function is causing deduction failures, while foo works perfectly fine—it all comes down to how C++20 interprets concept syntax in function signatures.

1. Why foo Works as Expected #

Your foo function explicitly defines four distinct template parameters (T, U, V, W), then uses the variadic Numerics concept to ensure every parameter is an arithmetic type. Each argument is tied to its own unique template parameter, so the compiler can independently deduce each type (int, double, float, long double) and confirm all meet the Numeric requirement.

This is functionally identical to writing:

template <typename T, typename U, typename V, typename W>
requires Numeric<T> && Numeric<U> && Numeric<V> && Numeric<W>
auto foo(T arg1, U arg2, V arg3, W arg4) {
    return 0.0 + arg1 + arg2 + arg3 + arg4;
}

2. The Hidden Issue with foo2’s Syntax #

When you write Numeric arg1 as a parameter type, C++20 doesn’t treat this as a per-parameter constraint. Instead, this syntax declares a single shared template parameter constrained by Numeric, and every parameter using Numeric as its type is forced to match that same template parameter.

In plain terms, your foo2 is implicitly rewritten by the compiler as:

template <Numeric T>
auto foo2(T arg1, T arg2, T arg3, T arg4) {
    return 0.0 + arg1 + arg2 + arg3 + arg4;
}

When you call foo2(1,2,3,4.0), the compiler tries to find one type T that works for all four arguments: int, int, int, and double. Since no type can be both int and double, deduction fails.

3. Fixing foo2 for Independent Deduction #

To get the behavior you want—each parameter deduced independently while still enforcing the Numeric constraint—you need to use the ConceptName auto syntax for each parameter. This tells the compiler to create a separate template parameter for every argument, each checked against the concept:

auto foo2(Numeric auto arg1, Numeric auto arg2, Numeric auto arg3, Numeric auto arg4) {
    return 0.0 + arg1 + arg2 + arg3 + arg4;
}

Now, calling foo2(1,2,3,4.0) will deduce four distinct types (int, int, int, double), all validated against Numeric, and the function compiles without issues.

Key Takeaway #

• ConceptName param binds all matching parameters to the same template parameter (they must share the same type).
• ConceptName auto param creates a unique template parameter for each parameter, allowing independent type deduction while enforcing the concept constraint.

内容的提问来源于stack exchange，提问作者sandthorn