带非类型模板参数的函数模板前向声明及代码编译合规性咨询

Hey there! Great question—let’s break down why your code is fully compliant with C++ standard rules:

1. Default template parameters can be added in later declarations #

C++ lets you add default values for template parameters in subsequent declarations (including the definition) of a function template, as long as:

• All declarations are in the same scope
• The default argument is valid for the parameter’s type

In your code:

• The forward declaration defines a non-type template parameter with type typename std::enable_if_t<std::is_same<std::decay_t<T>, int>::value>*. When the enable_if condition passes (i.e., when T decays to int), this type resolves to void*.
• The definition adds = nullptr as the default for that parameter—and since nullptr is a valid constant expression for void*, this is totally allowed by the standard.

2. SFINAE works as intended here #

Your enable_if check is correctly structured:

• When you call foo(int{}), T gets deduced to int&& (thanks to perfect forwarding). std::decay_t<T> strips away the reference, leaving int, so the enable_if condition evaluates to true.
• With the condition satisfied, the non-type parameter’s type becomes void*, and the default nullptr fills in that parameter, letting the template instantiate successfully.

3. Forward declaration and definition match correctly #

The forward declaration and definition of foo have identical template parameter type lists—only the definition adds the default argument for the non-type parameter. The standard allows this kind of incremental default argument addition for function templates, as long as the parameter types themselves stay consistent.

Modern compilers like Clang handle this pattern correctly, as you’ve seen. While older compiler versions might have had edge cases, this implementation is well within the standard’s rules.

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