enable_if 中的短路运算符

Question

我想编写一个模板化函数，它接受array<int, 3> 或int[3]。我试图在enable_if 中捕捉到这一点：

template<typename T>
enable_if_t<is_array_v<T> && extent_v<T> == 3U || !is_array_v<T> && tuple_size<T>::value == 3U> foo(const T& param) {}

不幸的是，对于int[3]，tupple_size 没有定义，这会导致模板在评估短路之前无法编译。

我也尝试过使用conditional 来执行此操作，但同样的问题是在考虑条件之前确保两个选项都对T 有效。

我知道我可以通过专业化来做到这一点。但是代码在函数体中是完全相同的。我讨厌在实现相同的情况下我专注于这一事实。

有没有办法在评估条件之前强制短路？

Answer 1

我建议另一种方法：2 个重载（总是更喜欢重载而不是模板特化）调用包含公共代码的公共函数：

namespace detail
{
template <class T>
auto foo_impl(const T& a)
{
    // common code
}
}

template <class T>
auto foo(const std::array<T, 3>& a)
{
    detail::foo_impl(a);
}

template <class T>
auto foo(const T(&a)[3])
{
    detail::foo_impl(a);
}

这很清楚，没有麻烦，并且避免了代码重复。

另一种方法是创建自己的特质：

template <class T, std::size_t Size>
struct my_is_array : std::false_type
{};

template <class T, std::size_t Size>
struct my_is_array<std::array<T, Size>, Size> : std::true_type
{};

template <class T, std::size_t Size>
struct my_is_array<T[Size], Size> : std::true_type
{};

template<typename T>
std::enable_if_t<my_is_array<T, 3>::value> foo(const T& param) {}

或者（我其实更喜欢这个）：

template <class T>
struct array_size_or_zero : std::integral_constant<std::size_t, 0>
{};

template <class T, std::size_t Size>
struct array_size_or_zero<std::array<T, Size>> : std::integral_constant<std::size_t, Size>
{};

template <class T, std::size_t Size>
struct array_size_or_zero<T[Size]> : std::integral_constant<std::size_t, Size>
{};

template<typename T>
std::enable_if_t<array_size_or_zero<T>::value == 3> foo(const T& param) {}

小心！！：foo 必须有参数引用，否则数组衰减为指针。

Answer 2

简而言之，模板替换必须始终有效。只定义一个特定的模板来匹配数组可能会更容易：

template <typename T>
struct IsArrayInt3 { enum: bool { value = false }; };

template <>
struct IsArrayInt3<int[3]> { enum: bool { value = true }; };

template <>
struct IsArrayInt3<std::array<int, 3>> { enum: bool { value = true }; };

Answer 3

利用extent<T> 用于非数组类型的事实为零，因此是假的，disjunction 派生自列表中第一个带短路的真值类型：

template<typename T>
enable_if_t<disjunction<extent<T>, tuple_size<T>>::value == 3U> foo(const T& param) {}

这可能太聪明了。注意这里不能使用disjunction_v。

---

conditional 也应该可以正常工作。诀窍是在选择正确的类型之前不要询问::value：

template<typename T>
enable_if_t<conditional_t<is_array_v<T>, extent<T>, tuple_size<T>>::value == 3U> 
    foo(const T& param) {}