Получить первый элемент std::tuple, удовлетворяющий трейту

Я использую С++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).


c++ c++17 template-meta-programming stdtuple variadic-templates
person tommaisey    schedule 11.11.2018    source источник
comment
Для меня непонятен ваш вопрос. Что не так с std::get_if<float>(my_tuple)?   -  person mkaes    schedule 11.11.2018
comment
Думаю, это было бы просто std::get<float> (my_tuple). Контекст, который я использую, немного сложнее, это просто пример. У меня есть кортеж кортежей, и я хочу вернуть ссылку на первый внутренний кортеж, который удовлетворяет некоторому признаку.   -  person tommaisey    schedule 11.11.2018

Ответы (3)


arrow_upward
2
arrow_downward

Вот удивительно простой способ без использования рекурсии:

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. Все остальное - С++14.

Обратите внимание, что в C++20 цикл for можно заменить на std::find и std::distance.

В идеале он должен генерировать исключение, а не возвращать -1, но компиляторам это, похоже, не нравится.

Вдохновленный этим ответом.

person Oktalist    schedule 11.11.2018
comment
Это действительно очень здорово! - person tommaisey; 12.11.2018

arrow_upward
2
arrow_downward

Если я правильно понимаю, что вы хотите... Я предлагаю вспомогательную структуру gf_h ("получить первого помощника") следующим образом

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 включены/выключены, поэтому они включены только в том случае, если в кортеже есть целочисленное (или плавающее) значение.

Ниже приведен полный пример компиляции

#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
 }
person max66    schedule 11.11.2018
comment
Ах очень приятно! Это легче расширить, чем решение, которое я нашел. Большое спасибо! - person tommaisey; 11.11.2018

arrow_upward
0
arrow_downward

Хорошо, я нашел способ сделать это таким образом, который не является общим для черты, но этого достаточно для моей текущей цели. Используя 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'

Мой вариант использования немного сложнее, он включает возврат первого вложенного кортежа, который сам содержит другой тип, но это должно передать основную идею.

person tommaisey    schedule 11.11.2018