获取 std::tuple 满足特征的第一个元素

Question

我正在使用 C++17。我想获得满足某种类型特征的元组元素。如果可以通用地提供该特性，那将是令人惊奇的，但我会对某个特性的特定功能感到满意。用法可能看起来像这样：

auto my_tuple = std::make_tuple { 0.f, 1 };

auto basic = get_if_integral (my_tuple);
auto fancy = get_if<std::is_floating_point> (my_tuple);

std::cout << basic; // '1'
std::cout << fancy; // '0.f'

理想情况下，如果不止一个元素满足该特征，这将无法编译，例如 std::get (std::tuple)。

Answer 1

好的，我找到了一种方法来完成此任务，该方法不是通用的特性，但对于我当前的目的来说已经足够了。使用 if constexpr 这看起来确实不错。我敢肯定这不是很惯用，但对我有用：

template <std::size_t Idx, typename... Us>
auto& get_if_integral_impl (std::tuple<Us...>& t)
{
    static_assert (Idx < std::tuple_size_v<std::tuple<Us...>>,
                   "No integral elements in this tuple.");

    if constexpr (std::is_integral<std::tuple_element_t<Idx, std::tuple<Us...>>>::value)
        return std::get<Idx> (t);
    else
        return get_if_integral_impl<Idx + 1> (t);
}

template<typename... Us>
auto& get_if_integral (std::tuple<Us...>& t)
{
    return get_if_integral_impl<0> (t);
}

auto tup = std::make_tuple (3.f, 2., 1, 0);
std::cout << get_if_integral (tup); // '1'

我的用例有点复杂，涉及返回第一个本身包含另一种类型的嵌套元组，但这应该传达基本思想。

Answer 2

如果我理解正确你想要什么...我建议一个辅助结构 gf_h ("get first helper") 如下

template <std::size_t, bool ...>
struct gf_h
 { };

template <std::size_t I, bool ... Bs>
struct gf_h<I, false, Bs...> : public gf_h<I+1u, Bs...>
 { };

template <std::size_t I, bool ... Bs>
struct gf_h<I, true, Bs...> : public std::integral_constant<std::size_t, I>
 { };

以及一些使用它的函数：

template <typename ... Us,
   std::size_t I = gf_h<0, std::is_integral<Us>::value...>::value>
auto get_first_integral (std::tuple<Us...> const & t)
 { return std::get<I>(t); }

template <typename ... Us,
   std::size_t I = gf_h<0, std::is_floating_point<Us>::value...>::value>
auto get_first_floating (std::tuple<Us...> const & t)
 { return std::get<I>(t); }

观察 SFINAE enabled/disabled 函数，因此仅当元组中存在整数（或浮点）值时才启用

下面是一个完整的编译示例

#include <tuple>
#include <iostream>

template <std::size_t, bool ...>
struct gf_h
 { };

template <std::size_t I, bool ... Bs>
struct gf_h<I, false, Bs...> : public gf_h<I+1u, Bs...>
 { };

template <std::size_t I, bool ... Bs>
struct gf_h<I, true, Bs...> : public std::integral_constant<std::size_t, I>
 { };

template <typename ... Us,
   std::size_t I = gf_h<0, std::is_integral<Us>::value...>::value>
auto get_first_integral (std::tuple<Us...> const & t)
 { return std::get<I>(t); }

template <typename ... Us,
   std::size_t I = gf_h<0, std::is_floating_point<Us>::value...>::value>
auto get_first_floating (std::tuple<Us...> const & t)
 { return std::get<I>(t); }

int main()
 {
   auto tup1 = std::make_tuple(3.f, 2., 1, 0);

   std::cout << get_first_integral(tup1) << std::endl; // 1
   std::cout << get_first_floating(tup1) << std::endl; // 3

   auto tup2 = std::make_tuple("abc", 4, 5);

   std::cout << get_first_integral(tup2) << std::endl; // 4
   // std::cout << get_first_floating(tup2) << std::endl; // error

   auto tup3 = std::make_tuple("xyz", 6., 7.f);

   // std::cout << get_first_integral(tup3) << std::endl; // error
   std::cout << get_first_floating(tup3) << std::endl; // 6
 }

Answer 3

这里有一个不使用递归的非常简单的方法：

template <template <typename...> typename T, typename... Ts>
constexpr int index_of_integral(const T<Ts...>&)
{
    const bool a[] = { std::is_integral_v<Ts>... };
    for (int i = 0; i < sizeof...(Ts); ++i) if (a[i]) return i;
    return -1;
}

template <typename T>
constexpr decltype(auto) get_if_integral(T&& t)
{
    return std::get<index_of_integral(t)>(std::forward<T>(t));
}

int main()
{
    constexpr auto t = std::make_tuple(3.14, 42, "xyzzy");
    static_assert(get_if_integral(t) == 42);
}

它可以很容易地扩展到特征参数化。

唯一使它成为 C++17 的是 is_integral_v 变量模板和单参数 static_assert。其他一切都是 C++14。

请注意，在 C++20 中，for 循环可以替换为 std::find 和 std::distance。

理想情况下它应该抛出异常而不是返回 -1，但编译器似乎不喜欢那样。

灵感来自 this answer.

获取 std::tuple 满足特征的第一个元素

Get first element of std::tuple satisfying trait

c++

template-meta-programming

variadic-templates

stdtuple

c++17