MSVC中std::conditional_t触发未用分支static_assert问题求解

现有如下C++模板代码：

template<TagType TTag, IsTag ...Tags>
struct RequiredTagList
{
    static constexpr const TagType index = TTag;
};

// ---------------------------------------------------------------

using fix::TagType = uint16_t;

template<fix::TagType Tag, IsTagList ...Ts>
struct Select_Tag_List;

template<fix::TagType Tag, IsTagList TagList, IsTagList ...TagLists>
struct Select_Tag_List<Tag, TagList, TagLists...>
{
    static constexpr const fix::TagType tag_index = TagList::index;

    using type = std::conditional_t<tag_index == Tag,
        TagList,
        typename Select_Tag_List<Tag, TagLists...>::type
    >;
};

template<fix::TagType Tag>
struct Select_Tag_List<Tag>
{
    static_assert(std::same_as<void,int>, "Tag not found, see template build stack");
};

template<fix::TagType Tag, IsTagList ...Ts>
using select_tag_list = Select_Tag_List<Tag, Ts...>;

template<fix::TagType Tag, IsTagList ...Ts>
using select_tag_list_t = typename Select_Tag_List<Tag, Ts...>::type;

其中IsTagList概念用于验证T是Required<TTag, Tags...>类型，且拥有类型为fix::TagType的静态成员属性T::index。

当使用以下模板参数调用时：

Select_Tag_List<268,fix::RequiredTagList<268,fix::Required<269>,fix::Required<270>,fix::Optional<271>>>

原本预期std::conditional_t不会评估Select_Tag_List<Tag>的特化，但其中的static_assert仍被触发。使用MSVC编译器时，发现它会同时评估条件的true和false分支的结果类型，因此尝试用自定义的延迟条件模板替换std::conditional_t：

template <bool Condition, typename Then, typename Else>
struct Lazy_Conditional;

template <typename Then, typename Else>
struct Lazy_Conditional<true, Then, Else>
{
    using type = Then;
};

template <typename Then, typename Else>
struct Lazy_Conditional<false, Then, Else>
{
    using type = Else;
};

template <bool Condition, typename Then, typename Else>
using lazy_conditional = Lazy_Conditional<Condition, Then, Else>;

template <bool Condition, typename Then, typename Else>
using lazy_conditional_t = typename lazy_conditional<Condition, Then, Else>::type;

但依旧报错：

error C2039: 'type': is not a member of 'meta::Select_Tag_List<268>'
Tag not found, see template build stack

需要实现条件为真时不评估false分支类型的逻辑。

问题根源在于：无论是std::conditional_t还是自定义的lazy_conditional_t，它们的模板参数在实例化时都会被求值（即typename Select_Tag_List<Tag, TagLists...>::type会被提前解析），导致即使条件为真，递归分支的模板也会被实例化，最终触发空参数特化的static_assert。

正确的做法是通过模板特化的短路逻辑来实现，仅当当前TagList不匹配时才递归实例化后续分支：

template<fix::TagType Tag, IsTagList ...Ts>
struct Select_Tag_List;

// 匹配成功的特化：当第一个TagList的index等于目标Tag时，直接返回该TagList
template<fix::TagType Tag, IsTagList ...Rest>
struct Select_Tag_List<Tag, RequiredTagList<Tag, Rest...>, IsTagList...>
{
    using type = RequiredTagList<Tag, Rest...>;
};

// 递归分支：当前TagList不匹配时，继续查找剩余的TagLists
template<fix::TagType Tag, IsTagList MismatchedList, IsTagList ...TagLists>
struct Select_Tag_List<Tag, MismatchedList, TagLists...>
{
    using type = typename Select_Tag_List<Tag, TagLists...>::type;
};

// 未找到的终止特化
template<fix::TagType Tag>
struct Select_Tag_List<Tag>
{
    static_assert(std::same_as<void,int>, "Tag not found, see template build stack");
};

// 保持原有的别名定义
template<fix::TagType Tag, IsTagList ...Ts>
using select_tag_list = Select_Tag_List<Tag, Ts...>;

template<fix::TagType Tag, IsTagList ...Ts>
using select_tag_list_t = typename Select_Tag_List<Tag, Ts...>::type;

原理说明 #

1. 新增的第一个特化会优先匹配index等于目标Tag的RequiredTagList，此时直接将type定义为该列表，不会触发任何递归，自然也不会实例化空参数的终止特化。
2. 只有当当前MismatchedList的index不匹配时，才会进入递归分支，实例化剩余参数的Select_Tag_List。
3. 只有当所有TagList都遍历完仍未匹配时，才会触发终止特化的static_assert。

这种方式利用了C++模板特化的匹配优先级，实现了真正的短路求值，避免了不必要的模板实例化。

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