constexpr上下文中&&运算符的异常行为解析

问题描述 #

尝试基于参数包的最后一个实参进行编译期决策：先判断参数包实参数量>0，再获取其最后一个元素。但调用空参数包时出现tuple访问无效索引的编译错误，明明使用了cnt-1，这是为什么？

原代码 #

#include <cstdio>
#include <concepts>
#include <utility>
#include <tuple>


template <typename... Args>
auto foo(Args&&... args)
{
    auto tuple = std::forward_as_tuple(std::forward<Args>(args)...);
    constexpr std::size_t cnt = sizeof...(Args);

    if constexpr (cnt > 0 && std::same_as<std::remove_cvref_t<std::tuple_element_t<cnt-1, decltype(tuple)>>, int>) {
        printf("last is int\n");
    } else {
        printf("last is not int\n");
    }
}

int main()
{
    foo(2);

    foo();
}

编译错误信息 #

/opt/compiler-explorer/gcc-12.2.0/include/c++/12.2.0/tuple: In instantiation of 'struct std::tuple_element<18446744073709551615, std::tuple<> >':
<source>:13:25:   required from 'auto foo(Args&& ...) [with Args = {}]'
<source>:24:8:   required from here
/opt/compiler-explorer/gcc-12.2.0/include/c++/12.2.0/tuple:1357:25: error: static assertion failed: tuple index must be in range
 1357 |       static_assert(__i < sizeof...(_Types), "tuple index must be in range");
      |                     ~~~~^~~~~~~~~~~~~~~~~~~
/opt/compiler-explorer/gcc-12.2.0/include/c++/12.2.0/tuple:1357:25: note: the comparison reduces to '(18446744073709551615 < 0)'
/opt/compiler-explorer/gcc-12.2.0/include/c++/12.2.0/tuple:1359:13: error: no type named 'type' in 'struct std::_Nth_type<18446744073709551615>'
 1359 |       using type = typename _Nth_type<__i, _Types...>::type;
      |             ^~~~

原因分析 #

1. 无符号整数下溢：std::size_t是无符号整数类型，当cnt=0时，cnt-1会触发无符号整数的下溢行为，结果变为std::size_t的最大值（即错误信息中的18446744073709551615），而非预期的负数。
2. if constexpr的短路求值局限性：if constexpr的逻辑短路仅在表达式求值阶段生效，但模板参数的实例化是在表达式求值之前进行的。即使cnt>0为false，编译器仍会先实例化std::tuple_element_t<cnt-1, decltype(tuple)>，此时超大的索引值对空tuple来说必然越界，触发tuple内部的static_assert检查。

解决方法 #

方法1：拆分if constexpr条件 #

将判断拆分为两层，先确保cnt>0后再实例化类型相关的模板：

#include <cstdio>
#include <concepts>
#include <utility>
#include <tuple>


template <typename... Args>
auto foo(Args&&... args)
{
    auto tuple = std::forward_as_tuple(std::forward<Args>(args)...);
    constexpr std::size_t cnt = sizeof...(Args);

    if constexpr (cnt > 0) {
        using LastType = std::remove_cvref_t<std::tuple_element_t<cnt-1, decltype(tuple)>>;
        if constexpr (std::same_as<LastType, int>) {
            printf("last is int\n");
        } else {
            printf("last is not int\n");
        }
    } else {
        printf("last is not int\n");
    }
}

int main()
{
    foo(2);
    foo();
}

方法2：使用辅助模板获取最后一个类型 #

通过自定义模板来安全获取参数包的最后一个类型，避免空参数包时的无效实例化：

#include <cstdio>
#include <concepts>
#include <utility>
#include <tuple>

// 辅助模板：获取参数包的最后一个类型
template<typename... Args>
struct last_type;

template<typename T>
struct last_type<T> { using type = T; };

template<typename T, typename... Rest>
struct last_type<T, Rest...> { using type = typename last_type<Rest...>::type; };

template<typename... Args>
using last_type_t = typename last_type<Args...>::type;

template <typename... Args>
auto foo(Args&&... args)
{
    constexpr std::size_t cnt = sizeof...(Args);

    if constexpr (cnt > 0 && std::same_as<std::remove_cvref_t<last_type_t<Args...>>, int>) {
        printf("last is int\n");
    } else {
        printf("last is not int\n");
    }
}

int main()
{
    foo(2);
    foo();
}

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