可变参数非类型模板中值类型重载函数歧义问题及实现问询

问题现象 #

首先看这段可正常运行的代码，它证明可变参数非类型模板中每个值都有独立类型：

#include <iostream>
#include <typeinfo>

template <typename T> void print_type(const T &) { 
    std::cout << typeid(T).name() << '\n'; 
}

template <auto ... VALUE> void print_types_0() { 
    (print_type(VALUE), ...); 
}

int main()
{
    print_types_0<0u, 0ll>(); // GCC 13.2.0输出"j x "（对应unsigned和long long）
}

但基于这个逻辑写出的以下代码却报歧义错误：

#include <iostream>

template <unsigned U> void vtemplate()      { std::cout << "unsigned "; }
template <long long LL> void vtemplate()    { std::cout << "long long "; }

template <auto ... VALUE> void print_types_1() { 
    (vtemplate<VALUE>(), ...); 
}

int main()
{
    print_types_1<1u, 1ll>(); // 编译错误
}

报错信息如下：

In instantiation of 'void print_types_1() [with auto ...VALUE = {1, 1}]':
  required from here
error: call of overloaded 'vtemplate<1>()' is ambiguous
template <auto ... VALUE> void print_types_1() { (vtemplate<VALUE>(), ...); }
                                                   ~~~~~~~~~~~~~~~~^~
note: candidate: 'void vtemplate() [with unsigned int U = 1]'
template <unsigned U> void vtemplate()      { std::cout << "unsigned "; }
                           ^~~~~~~~~
note: candidate: 'void vtemplate() [with long long int LL = 1]'
template <long long LL> void vtemplate()     { std::cout << "long long "; }        
                             ^~~~~~~~~

推测确认 #

你的推测完全正确，核心原因如下：

1. 模板重载解析规则差异：
   • 第一段代码中，print_type(VALUE)是函数调用，编译器会根据实参VALUE的实际类型直接推导模板参数T，不存在类型转换，因此无歧义。
   • 第二段代码中，vtemplate<VALUE>是模板实例化调用，编译器会尝试将VALUE的类型转换为模板的非类型参数类型。比如1u（unsigned类型）可以隐式转换为long long，1ll也可以隐式转换为unsigned，导致两个模板都成为可行候选，且没有优先级更高的匹配，最终触发歧义错误。
2. C++确实不存在“模板值重载”机制，非类型模板参数的重载解析会考虑隐式转换，这和函数参数的重载解析逻辑不同。

实现“值模板”重载的方法 #

要实现基于非类型参数类型的重载，需要通过约束让每个模板只接受特定类型的参数，避免隐式转换带来的歧义，以下是几种可行方案：

方案1：使用if constexpr（C++17及以上） #

将逻辑合并到一个模板中，通过编译期判断参数类型：

#include <iostream>
#include <type_traits>

template <auto VALUE> void vtemplate() {
    if constexpr (std::is_same_v<decltype(VALUE), unsigned>) {
        std::cout << "unsigned ";
    } else if constexpr (std::is_same_v<decltype(VALUE), long long>) {
        std::cout << "long long ";
    }
}

template <auto ... VALUE> void print_types_1() { 
    (vtemplate<VALUE>(), ...); 
}

int main()
{
    print_types_1<1u, 1ll>(); // 输出：unsigned long long 
}

方案2：使用SFINAE约束（C++11及以上） #

通过std::enable_if让每个模板仅匹配特定类型的非类型参数：

#include <iostream>
#include <type_traits>

template <unsigned U> 
typename std::enable_if<std::is_same<decltype(U), unsigned>::value>::type 
vtemplate() {
    std::cout << "unsigned ";
}

template <long long LL> 
typename std::enable_if<std::is_same<decltype(LL), long long>::value>::type 
vtemplate() {
    std::cout << "long long ";
}

template <auto ... VALUE> void print_types_1() { 
    (vtemplate<VALUE>(), ...); 
}

int main()
{
    print_types_1<1u, 1ll>(); // 输出：unsigned long long 
}

方案3：使用requires子句（C++20及以上） #

这是C++20引入的更简洁的约束方式：

#include <iostream>
#include <type_traits>

template <unsigned U> requires std::is_same_v<decltype(U), unsigned>
void vtemplate() { std::cout << "unsigned "; }

template <long long LL> requires std::is_same_v<decltype(LL), long long>
void vtemplate() { std::cout << "long long "; }

template <auto ... VALUE> void print_types_1() { 
    (vtemplate<VALUE>(), ...); 
}

int main()
{
    print_types_1<1u, 1ll>(); // 输出：unsigned long long 
}

这些方案的核心都是通过编译期约束，确保每个非类型参数只会匹配到唯一的模板，从而消除歧义。

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