使用引用实例化带非类型模板参数的模板为何编译报错？

定义与原实现 #

首先定义了value_list结构体模板：

template <decltype(auto)... values>
struct value_list
{};

为实现按索引访问模板参数，原解决方案代码如下：

#include <type_traits>

namespace details
{
// 第二个参数T用于避免“Ambiguous partial specializations of 'at_impl<0, value_list<1>>'”错误
template <std::size_t I, typename T, typename ValueList>
struct at_impl;

template <decltype(auto) Head, decltype(auto)... Rest>
struct at_impl<0, void, value_list<Head, Rest...>>
{
    static constexpr decltype(auto) value = Head;
};

template <std::size_t I, decltype(auto) Head, decltype(auto)... Rest>
struct at_impl<I, int, value_list<Head, Rest...>>
{
    static constexpr decltype(auto) value = at_impl<I-1, std::conditional_t<I-1 == 0, void, int>, value_list<Rest...>>::value;
};
}  // namespace details

template <std::size_t I, typename ValueList>
struct at
{
    static constexpr decltype(auto) value = details::at_impl<I, std::conditional_t<I == 0, void, int>, ValueList>::value;
};

template <std::size_t I, typename ValueList>
inline constexpr decltype(auto) at_v = at<I, ValueList>::value;

正常工作场景（值类型参数） #

使用值类型实例化value_list时代码可正常运行：

#include <iostream>

#define LOG(x) std::cout << #x << ": " << x << '\n'

int main()
{
    static constexpr int i = 5;
    const std::size_t index = 0;
    LOG((at_v<index, value_list<i>>));
    
    return 0;
}

输出：

(at_v<index, value_list<i>>): 5

编译失败场景（引用类型参数） #

使用引用类型实例化value_list时编译报错：

int main()
{
    static constexpr int i = 5;
    const std::size_t index = 0;

    constexpr const int & ri = i;
    LOG((at_v<index, value_list<ri>>));
    
    return 0;
}

错误信息：

implicit instantiation of undefined template 'details::at_impl<0, void, value_list<i>>'

原因分析 #

1. 核心问题：当value_list的模板参数是引用类型时，编译器在匹配at_impl<0, void, value_list<Head, Rest...>>特化时，判定static constexpr decltype(auto) value = Head;的初始化不符合常量表达式要求，导致该特化被忽略，回退到未定义的主模板，触发编译错误。
2. 辅助因素：原代码使用void和int作为区分特化的第二个参数，这种方式不够直观，容易引发编译器在处理引用类型模板参数时的匹配混淆。

修复方案 #

方案一：用bool类型参数明确区分特化 #

改用bool类型模板参数清晰区分I=0和I≠0的场景，避免匹配歧义：

#include <type_traits>

template <decltype(auto)... values>
struct value_list
{};

namespace details
{
template <std::size_t I, bool IsZero, typename ValueList>
struct at_impl;

template <decltype(auto) Head, decltype(auto)... Rest>
struct at_impl<0, true, value_list<Head, Rest...>>
{
    static constexpr decltype(auto) value = Head;
};

template <std::size_t I, decltype(auto) Head, decltype(auto)... Rest>
struct at_impl<I, false, value_list<Head, Rest...>>
{
    static constexpr decltype(auto) value = at_impl<I-1, I-1 == 0, value_list<Rest...>>::value;
};
}  // namespace details

template <std::size_t I, typename ValueList>
struct at
{
    static constexpr decltype(auto) value = details::at_impl<I, I == 0, ValueList>::value;
};

template <std::size_t I, typename ValueList>
inline constexpr decltype(auto) at_v = at<I, ValueList>::value;

// 测试代码
#include <iostream>
#define LOG(x) std::cout << #x << ": " << x << '\n'

int main()
{
    static constexpr int i = 5;
    const std::size_t index = 0;
    LOG((at_v<index, value_list<i>>));
    
    constexpr const int & ri = i;
    LOG((at_v<index, value_list<ri>>));
    
    return 0;
}

方案二：用std::enable_if避免特化歧义 #

利用std::enable_if在编译期选择正确的特化，代码更简洁：

#include <type_traits>

template <decltype(auto)... values>
struct value_list
{};

namespace details
{
template <std::size_t I, typename ValueList, typename = void>
struct at_impl;

template <decltype(auto) Head, decltype(auto)... Rest>
struct at_impl<0, value_list<Head, Rest...>, std::enable_if_t<true>>
{
    static constexpr decltype(auto) value = Head;
};

template <std::size_t I, decltype(auto) Head, decltype(auto)... Rest>
struct at_impl<I, value_list<Head, Rest...>, std::enable_if_t<I != 0>>
{
    static constexpr decltype(auto) value = at_impl<I-1, value_list<Rest...>>::value;
};
}  // namespace details

template <std::size_t I, typename ValueList>
inline constexpr decltype(auto) at_v = details::at_impl<I, ValueList>::value;

// 测试代码
#include <iostream>
#define LOG(x) std::cout << #x << ": " << x << '\n'

int main()
{
    static constexpr int i = 5;
    const std::size_t index = 0;
    LOG((at_v<index, value_list<i>>));
    
    constexpr const int & ri = i;
    LOG((at_v<index, value_list<ri>>));
    
    return 0;
}

两种方案均可正确处理值类型和引用类型的value_list参数，实现按索引访问的功能。

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