Как вы можете перебирать элементы std :: tuple?

113

Как я могу перебирать кортеж (используя C ++ 11)? Я пробовал следующее:

for(int i=0; i<std::tuple_size<T...>::value; ++i) 
  std::get<i>(my_tuple).do_sth();

но это не работает:

Ошибка 1: извините, не реализовано: невозможно развернуть "Listener ..." в список аргументов фиксированной длины.
Ошибка 2: я не могу появиться в постоянном выражении.

Итак, как мне правильно перебирать элементы кортежа?

einpoklum
источник
2
Могу я спросить, как вы компилируете в C ++ 0x? Насколько мне известно, он еще не выпущен и не готов.
Burkhard
5
g ++ содержит экспериментальную поддержку некоторых функций C ++ 0X, включая вариативные шаблоны, начиная с версии 4.3. Другие компиляторы делают то же самое (с другими наборами функций, если вы хотите использовать их в производственной среде, вы вернулись в 90-е годы с широким разнообразием поддержки передовых технологий)
AProgrammer
Я использую g ++ версии 4.4 с std = c ++ 0x
9
Этот вопрос требует обновления C ++ 11.
Omnifarious
2
@Omnifarious сейчас, ему нужно обновление C ++ 14
pepper_chico

Ответы:

27

Boost.Fusion - это возможность:

Непроверенный пример:

struct DoSomething
{
    template<typename T>
    void operator()(T& t) const
    {
        t.do_sth();
    }
};

tuple<....> t = ...;
boost::fusion::for_each(t, DoSomething());
Эрик Маленфант
источник
@ViktorSehr AFAICT это не так (по крайней мере, в GCC 4.7.2)? Есть ли намек?
sehe
@ViktorSehr Найдено проблему: об ошибке / бездействие вызывает поведение слияния, зависит от того , из включает в себя, см подталкивание билет # 8418 для более подробной информации
sehe
необходимо использовать boost :: fusion :: tuple вместо std :: tuple, чтобы это работало.
Marcin
В GCC 8.1 / mingw-64 я получаю два предупреждения об использовании boost :: fusion :: for_each с лямбда-выражениями std: boost / mpl / assert.hpp: 188: 21: предупреждение: ненужные круглые скобки в объявлении assert_arg [-Wparentheses] не удалось ************ (Pred :: ************ boost / mpl / assert.hpp: 193: 21: предупреждение: ненужные скобки в объявление 'assert_not_arg' [-Wparentheses] не удалось ************ (boost :: mpl :: not_ <Pred> :: ************
Хоссейн
129

У меня есть ответ, основанный на итерации по кортежу :

#include <tuple>
#include <utility> 
#include <iostream>

template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  print(std::tuple<Tp...>& t)
  { }

template<std::size_t I = 0, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  print(std::tuple<Tp...>& t)
  {
    std::cout << std::get<I>(t) << std::endl;
    print<I + 1, Tp...>(t);
  }

int
main()
{
  typedef std::tuple<int, float, double> T;
  T t = std::make_tuple(2, 3.14159F, 2345.678);

  print(t);
}

Обычная идея - использовать рекурсию времени компиляции. Фактически, эта идея используется, чтобы сделать printf безопасным по типу, как указано в исходных документах по кортежу.

Это можно легко обобщить до for_eachкортежей:

#include <tuple>
#include <utility> 

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  for_each(std::tuple<Tp...> &, FuncT) // Unused arguments are given no names.
  { }

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  for_each(std::tuple<Tp...>& t, FuncT f)
  {
    f(std::get<I>(t));
    for_each<I + 1, FuncT, Tp...>(t, f);
  }

Хотя тогда это требует некоторых усилий, чтобы FuncTпредставить что-то с соответствующими перегрузками для каждого типа, который может содержать кортеж. Это работает лучше всего, если вы знаете, что все элементы кортежа будут иметь общий базовый класс или что-то подобное.

EMSR
источник
5
Спасибо за красивый простой пример. Для новичков в C ++, которые хотят узнать, как это работает, см. SFINAE и enable_ifдокументацию .
Faheem Mitha
Его легко можно было бы обобщить до общего for_each. Фактически, я сделал это сам. :-) Думаю, этот ответ был бы более полезным, если бы он был уже обобщенным.
Omnifarious
4
Там я добавил обобщение, потому что оно мне действительно было нужно, и я думаю, что было бы полезно увидеть его другим.
Omnifarious
2
Примечание. Вам также могут потребоваться версии с const std::tuple<Tp...>&.. Если вы не собираетесь изменять кортежи во время итерации, этих constверсий будет достаточно.
lethal-guitar
2
Не так, как написано .. Вы можете сделать версию с перевернутой индексацией - начните с I = sizeof ... (Tp) и начните отсчет. Затем явно укажите максимальное количество аргументов. Вы также можете сделать версию, которая сломалась бы по типу тега, например, break_t. Затем вы должны поместить объект этого типа тега в свой кортеж, когда захотите остановить печать. Или вы можете указать тип стопа в качестве шаблона. Очевидно, вы не могли сломаться во время выполнения.
emsr
55

В C ++ 17, вы можете использовать std::applyс кратным выражения :

std::apply([](auto&&... args) {((/* args.dosomething() */), ...);}, the_tuple);

Полный пример печати кортежа:

#include <tuple>
#include <iostream>

int main()
{
    std::tuple t{42, 'a', 4.2}; // Another C++17 feature: class template argument deduction
    std::apply([](auto&&... args) {((std::cout << args << '\n'), ...);}, t);
}

[Интернет-пример на Coliru]

Это решение решает вопрос о порядке оценки в ответе М. Алаггана .

xskxzr
источник
1
Не могли бы вы объяснить , что происходит здесь: ((std::cout << args << '\n'), ...);? Лямбда вызывается один раз с элементами кортежа, распакованными как args, но что случилось с двойными круглыми скобками?
helmesjo
4
@helmesjo Здесь он заменяется запятой ((std::cout << arg1 << '\n'), (std::cout << arg2 << '\n'), (std::cout << arg3 << '\n')).
xskxzr
Обратите внимание, что в случае, если вы хотите сделать что-то, что недопустимо в выражении-запятой (например, объявление переменных и блоков), вы можете поместить все это в метод и просто вызвать его из свернутого-запятого-выражения.
Мирал
24

В C ++ 17 это можно сделать:

std::apply([](auto ...x){std::make_tuple(x.do_something()...);} , the_tuple);

Это уже работает в Clang ++ 3.9 с использованием std :: experimental :: apply.

Мохаммад Алагган
источник
4
Разве это не приводит к тому, что итерация - то есть вызовы do_something()- происходит в неопределенном порядке, потому что пакет параметров раскрывается в вызове функции (), в которой аргументы имеют неопределенный порядок? Это может быть очень важно; Я предполагаю, что большинство людей ожидают, что упорядочение будет гарантированно происходить в том же порядке, что и члены, то есть как индексы для std::get<>(). AFAIK, чтобы получить гарантированный заказ в подобных случаях, расширение должно выполняться внутри {braces}. Я ошибся? В этом ответе акцент делается на таком порядке: stackoverflow.com/a/16387374/2757035
underscore_d
21

Используйте Boost.Hana и общие лямбды:

#include <tuple>
#include <iostream>
#include <boost/hana.hpp>
#include <boost/hana/ext/std/tuple.hpp>

struct Foo1 {
    int foo() const { return 42; }
};

struct Foo2 {
    int bar = 0;
    int foo() { bar = 24; return bar; }
};

int main() {
    using namespace std;
    using boost::hana::for_each;

    Foo1 foo1;
    Foo2 foo2;

    for_each(tie(foo1, foo2), [](auto &foo) {
        cout << foo.foo() << endl;
    });

    cout << "foo2.bar after mutation: " << foo2.bar << endl;
}

http://coliru.stacked-crooked.com/a/27b3691f55caf271

перец чико
источник
4
Пожалуйста, пожалуйста, не уходи using namespace boost::fusion(особенно вместе с using namespace std). Теперь нет никакого способа узнать , что ли for_eachэто std::for_eachилиboost::fusion::for_each
Bulletmagnet
3
@Bulletmagnet это было сделано для краткости, и ADL может справиться с этим без проблем. Кроме того, он также функционирует локально.
pepper_chico
18

C ++ вводит операторы расширения для этой цели. Первоначально они были на пути к C ++ 20, но чуть не попали в обрез из-за нехватки времени на пересмотр формулировок языка (см. Здесь и здесь ).

В настоящее время согласованный синтаксис (см. Ссылки выше):

{
    auto tup = std::make_tuple(0, 'a', 3.14);
    template for (auto elem : tup)
        std::cout << elem << std::endl;
}
Daniels
источник
15

Более простой, интуитивно понятный и удобный для компилятора способ сделать это в C ++ 17, используя if constexpr:

// prints every element of a tuple
template<size_t I = 0, typename... Tp>
void print(std::tuple<Tp...>& t) {
    std::cout << std::get<I>(t) << " ";
    // do things
    if constexpr(I+1 != sizeof...(Tp))
        print<I+1>(t);
}

Это рекурсия времени компиляции, аналогичная той, что представлена ​​@emsr. Но это не использует SFINAE, поэтому (я думаю) он более удобен для компилятора.

Stypox
источник
8

Вам нужно использовать метапрограммирование шаблона, как показано здесь с Boost.Tuple:

#include <boost/tuple/tuple.hpp>
#include <iostream>

template <typename T_Tuple, size_t size>
struct print_tuple_helper {
    static std::ostream & print( std::ostream & s, const T_Tuple & t ) {
        return print_tuple_helper<T_Tuple,size-1>::print( s, t ) << boost::get<size-1>( t );
    }
};

template <typename T_Tuple>
struct print_tuple_helper<T_Tuple,0> {
    static std::ostream & print( std::ostream & s, const T_Tuple & ) {
        return s;
    }
};

template <typename T_Tuple>
std::ostream & print_tuple( std::ostream & s, const T_Tuple & t ) {
    return print_tuple_helper<T_Tuple,boost::tuples::length<T_Tuple>::value>::print( s, t );
}

int main() {

    const boost::tuple<int,char,float,char,double> t( 0, ' ', 2.5f, '\n', 3.1416 );
    print_tuple( std::cout, t );

    return 0;
}

В C ++ 0x print_tuple()вместо этого вы можете написать функцию вариативного шаблона.

Марк Мутц - mmutz
источник
8

Сначала определите несколько помощников индекса:

template <size_t ...I>
struct index_sequence {};

template <size_t N, size_t ...I>
struct make_index_sequence : public make_index_sequence<N - 1, N - 1, I...> {};

template <size_t ...I>
struct make_index_sequence<0, I...> : public index_sequence<I...> {};

С помощью вашей функции вы хотите применить к каждому элементу кортежа:

template <typename T>
/* ... */ foo(T t) { /* ... */ }

ты можешь написать:

template<typename ...T, size_t ...I>
/* ... */ do_foo_helper(std::tuple<T...> &ts, index_sequence<I...>) {
    std::tie(foo(std::get<I>(ts)) ...);
}

template <typename ...T>
/* ... */ do_foo(std::tuple<T...> &ts) {
    return do_foo_helper(ts, make_index_sequence<sizeof...(T)>());
}

Или, если fooвозвращается void, используйте

std::tie((foo(std::get<I>(ts)), 1) ... );

Примечание. В C ++ 14 make_index_sequenceуже определено ( http://en.cppreference.com/w/cpp/utility/integer_sequence ).

Если вам нужен порядок оценки слева направо, подумайте о следующем:

template <typename T, typename ...R>
void do_foo_iter(T t, R ...r) {
    foo(t);
    do_foo(r...);
}

void do_foo_iter() {}

template<typename ...T, size_t ...I>
void do_foo_helper(std::tuple<T...> &ts, index_sequence<I...>) {
    do_foo_iter(std::get<I>(ts) ...);
}

template <typename ...T>
void do_foo(std::tuple<T...> &ts) {
    do_foo_helper(ts, make_index_sequence<sizeof...(T)>());
}
Филипп Х.
источник
1
Перед вызовом должен привести возвращаемое значение fooк, чтобы избежать возможной патологической перегрузки оператора. voidoperator,
Yakk - Adam Nevraumont
7

Вот простой способ C ++ 17 для перебора элементов кортежа с помощью стандартной библиотеки:

#include <tuple>      // std::tuple
#include <functional> // std::invoke

template <
    size_t Index = 0, // start iteration at 0 index
    typename TTuple,  // the tuple type
    size_t Size =
        std::tuple_size_v<
            std::remove_reference_t<TTuple>>, // tuple size
    typename TCallable, // the callable to bo invoked for each tuple item
    typename... TArgs   // other arguments to be passed to the callable 
>
void for_each(TTuple&& tuple, TCallable&& callable, TArgs&&... args)
{
    if constexpr (Index < Size)
    {
        std::invoke(callable, args..., std::get<Index>(tuple));

        if constexpr (Index + 1 < Size)
            for_each<Index + 1>(
                std::forward<TTuple>(tuple),
                std::forward<TCallable>(callable),
                std::forward<TArgs>(args)...);
    }
}

Пример:

#include <iostream>

int main()
{
    std::tuple<int, char> items{1, 'a'};
    for_each(items, [](const auto& item) {
        std::cout << item << "\n";
    });
}

Вывод:

1
a

Это можно расширить, чтобы условно разорвать цикл в случае, если вызываемый объект возвращает значение (но все еще работает с вызываемыми объектами, которые не возвращают присваиваемое значение типа bool, например void):

#include <tuple>      // std::tuple
#include <functional> // std::invoke

template <
    size_t Index = 0, // start iteration at 0 index
    typename TTuple,  // the tuple type
    size_t Size =
    std::tuple_size_v<
    std::remove_reference_t<TTuple>>, // tuple size
    typename TCallable, // the callable to bo invoked for each tuple item
    typename... TArgs   // other arguments to be passed to the callable 
    >
    void for_each(TTuple&& tuple, TCallable&& callable, TArgs&&... args)
{
    if constexpr (Index < Size)
    {
        if constexpr (std::is_assignable_v<bool&, std::invoke_result_t<TCallable&&, TArgs&&..., decltype(std::get<Index>(tuple))>>)
        {
            if (!std::invoke(callable, args..., std::get<Index>(tuple)))
                return;
        }
        else
        {
            std::invoke(callable, args..., std::get<Index>(tuple));
        }

        if constexpr (Index + 1 < Size)
            for_each<Index + 1>(
                std::forward<TTuple>(tuple),
                std::forward<TCallable>(callable),
                std::forward<TArgs>(args)...);
    }
}

Пример:

#include <iostream>

int main()
{
    std::tuple<int, char> items{ 1, 'a' };
    for_each(items, [](const auto& item) {
        std::cout << item << "\n";
    });

    std::cout << "---\n";

    for_each(items, [](const auto& item) {
        std::cout << item << "\n";
        return false;
    });
}

Вывод:

1
a
---
1
Марцин Завейски
источник
5

Если вы хотите использовать std :: tuple и у вас есть компилятор C ++, который поддерживает вариативные шаблоны, попробуйте приведенный ниже код (протестирован с g ++ 4.5). Это должен быть ответ на ваш вопрос.

#include <tuple>

// ------------- UTILITY---------------
template<int...> struct index_tuple{}; 

template<int I, typename IndexTuple, typename... Types> 
struct make_indexes_impl; 

template<int I, int... Indexes, typename T, typename ... Types> 
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...> 
{ 
    typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type; 
}; 

template<int I, int... Indexes> 
struct make_indexes_impl<I, index_tuple<Indexes...> > 
{ 
    typedef index_tuple<Indexes...> type; 
}; 

template<typename ... Types> 
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...> 
{}; 

// ----------- FOR EACH -----------------
template<typename Func, typename Last>
void for_each_impl(Func&& f, Last&& last)
{
    f(last);
}

template<typename Func, typename First, typename ... Rest>
void for_each_impl(Func&& f, First&& first, Rest&&...rest) 
{
    f(first);
    for_each_impl( std::forward<Func>(f), rest...);
}

template<typename Func, int ... Indexes, typename ... Args>
void for_each_helper( Func&& f, index_tuple<Indexes...>, std::tuple<Args...>&& tup)
{
    for_each_impl( std::forward<Func>(f), std::forward<Args>(std::get<Indexes>(tup))...);
}

template<typename Func, typename ... Args>
void for_each( std::tuple<Args...>& tup, Func&& f)
{
   for_each_helper(std::forward<Func>(f), 
                   typename make_indexes<Args...>::type(), 
                   std::forward<std::tuple<Args...>>(tup) );
}

template<typename Func, typename ... Args>
void for_each( std::tuple<Args...>&& tup, Func&& f)
{
   for_each_helper(std::forward<Func>(f), 
                   typename make_indexes<Args...>::type(), 
                   std::forward<std::tuple<Args...>>(tup) );
}

boost :: fusion - еще один вариант, но для него требуется собственный тип кортежа: boost :: fusion :: tuple. Давайте лучше придерживаться стандарта! Вот тест:

#include <iostream>

// ---------- FUNCTOR ----------
struct Functor 
{
    template<typename T>
    void operator()(T& t) const { std::cout << t << std::endl; }
};

int main()
{
    for_each( std::make_tuple(2, 0.6, 'c'), Functor() );
    return 0;
}

сила вариативных шаблонов!

сигидаги
источник
Я пробовал ваше первое решение, но оно не работает с этой функцией на парах. Есть идеи, почему? Template <typename T, typename U> void addt (pair <T, U> p) {cout << p.first + p.second << endl; } int main (int argc, char * argv []) {cout << "Привет." << endl; for_each (make_tuple (2,3,4), [] (int i) {cout << i << endl;}); for_each (make_tuple (make_pair (1,2), make_pair (3,4)), addt); возврат 0; }
user2023370
Жаль, что этот ответ написан так многословно, потому что я считаю способ итерации (for_each_impl) самым элегантным из всех решений, которые я видел.
joki
3

В MSVC STL есть функция _For_each_tuple_element (не задокументирована):

#include <tuple>

// ...

std::tuple<int, char, float> values{};
std::_For_each_tuple_element(values, [](auto&& value)
{
    // process 'value'
});
Марцин Завейски
источник
2

Другие упомянули несколько хорошо продуманных сторонних библиотек, к которым вы можете обратиться. Однако, если вы используете C ++ без этих сторонних библиотек, следующий код может помочь.

namespace detail {

template <class Tuple, std::size_t I, class = void>
struct for_each_in_tuple_helper {
  template <class UnaryFunction>
  static void apply(Tuple&& tp, UnaryFunction& f) {
    f(std::get<I>(std::forward<Tuple>(tp)));
    for_each_in_tuple_helper<Tuple, I + 1u>::apply(std::forward<Tuple>(tp), f);
  }
};

template <class Tuple, std::size_t I>
struct for_each_in_tuple_helper<Tuple, I, typename std::enable_if<
    I == std::tuple_size<typename std::decay<Tuple>::type>::value>::type> {
  template <class UnaryFunction>
  static void apply(Tuple&&, UnaryFunction&) {}
};

}  // namespace detail

template <class Tuple, class UnaryFunction>
UnaryFunction for_each_in_tuple(Tuple&& tp, UnaryFunction f) {
  detail::for_each_in_tuple_helper<Tuple, 0u>
      ::apply(std::forward<Tuple>(tp), f);
  return std::move(f);
}

Примечание: код компилируется с любым компилятором, поддерживающим C ++ 11, и сохраняет согласованность с дизайном стандартной библиотеки:

  1. Кортеж не обязательно должен быть std::tuple, и вместо этого может быть все, что поддерживает std::getи std::tuple_size; в частности, std::arrayи std::pairмогут быть использованы;

  2. Кортеж может быть ссылочного типа или cv-квалифицированным;

  3. Он ведет себя так же, как и std::for_each, и возвращает ввод UnaryFunction;

  4. Для пользователей C ++ 14 (или более поздней версии) typename std::enable_if<T>::typeи typename std::decay<T>::typeможет быть заменен их упрощенной версией,std::enable_if_t<T> и std::decay_t<T>;

  5. Для пользователей C ++ 17 (или более поздней версии) std::tuple_size<T>::valueможет быть заменен его упрощенной версией,std::tuple_size_v<T> .

  6. Для пользователей C ++ 20 (или более поздней версии) эта SFINAEфункция может быть реализована с помощью Concepts.

Графен
источник
2

Используя constexprand if constexpr(C ++ 17), это довольно просто и понятно:

template <std::size_t I = 0, typename ... Ts>
void print(std::tuple<Ts...> tup) {
  if constexpr (I == sizeof...(Ts)) {
    return;
  } else {
    std::cout << std::get<I>(tup) << ' ';
    print<I+1>(tup);
  }
}
Андреас Д.М.
источник
1

Я мог бы опоздать на этот поезд, но это будет здесь для справки в будущем.
Вот моя конструкция, основанная на этом ответе и по сути :

#include <tuple>
#include <utility>

template<std::size_t N>
struct tuple_functor
{
    template<typename T, typename F>
    static void run(std::size_t i, T&& t, F&& f)
    {
        const std::size_t I = (N - 1);
        switch(i)
        {
        case I:
            std::forward<F>(f)(std::get<I>(std::forward<T>(t)));
            break;

        default:
            tuple_functor<I>::run(i, std::forward<T>(t), std::forward<F>(f));
        }
    }
};

template<>
struct tuple_functor<0>
{
    template<typename T, typename F>
    static void run(std::size_t, T, F){}
};

Затем вы используете его следующим образом:

template<typename... T>
void logger(std::string format, T... args) //behaves like C#'s String.Format()
{
    auto tp = std::forward_as_tuple(args...);
    auto fc = [](const auto& t){std::cout << t;};

    /* ... */

    std::size_t some_index = ...
    tuple_functor<sizeof...(T)>::run(some_index, tp, fc);

    /* ... */
}

Здесь есть место для улучшений.


Согласно коду OP, это станет следующим:

const std::size_t num = sizeof...(T);
auto my_tuple = std::forward_as_tuple(t...);
auto do_sth = [](const auto& elem){/* ... */};
for(int i = 0; i < num; ++i)
    tuple_functor<num>::run(i, my_tuple, do_sth);
bit2shift
источник
1

Из всех ответов, которые я видел здесь, здесь и здесь , мне больше всего понравился способ итерации @sigidagi . К сожалению, его ответ очень многословен, что, на мой взгляд, затемняет присущую ему ясность.

Это моя версия его решения, которая более лаконична и работает с std::tuple, std::pairи std::array.

template<typename UnaryFunction>
void invoke_with_arg(UnaryFunction)
{}

/**
 * Invoke the unary function with each of the arguments in turn.
 */
template<typename UnaryFunction, typename Arg0, typename... Args>
void invoke_with_arg(UnaryFunction f, Arg0&& a0, Args&&... as)
{
    f(std::forward<Arg0>(a0));
    invoke_with_arg(std::move(f), std::forward<Args>(as)...);
}

template<typename Tuple, typename UnaryFunction, std::size_t... Indices>
void for_each_helper(Tuple&& t, UnaryFunction f, std::index_sequence<Indices...>)
{
    using std::get;
    invoke_with_arg(std::move(f), get<Indices>(std::forward<Tuple>(t))...);
}

/**
 * Invoke the unary function for each of the elements of the tuple.
 */
template<typename Tuple, typename UnaryFunction>
void for_each(Tuple&& t, UnaryFunction f)
{
    using size = std::tuple_size<typename std::remove_reference<Tuple>::type>;
    for_each_helper(
        std::forward<Tuple>(t),
        std::move(f),
        std::make_index_sequence<size::value>()
    );
}

Демо: coliru

C ++ 14 std::make_index_sequenceможет быть реализован для C ++ 11 .

Джоки
источник
0

Кортеж обеспечивает поднимать торг вспомогательных функций get_head()и get_tail()поэтому ваши вспомогательные функции могут выглядеть следующим образом :

inline void call_do_sth(const null_type&) {};

template <class H, class T>
inline void call_do_sth(cons<H, T>& x) { x.get_head().do_sth(); call_do_sth(x.get_tail()); }

как описано здесь http://www.boost.org/doc/libs/1_34_0/libs/tuple/doc/tuple_advanced_interface.html

с std::tupleним должно быть похоже.

На самом деле, к сожалению std::tuple , похоже, не предоставляет такой интерфейс, поэтому методы, предложенные ранее, должны работать, или вам нужно будет переключиться на то, boost::tupleчто имеет другие преимущества (например, уже предоставленные операторы io). Хотя boost::tupleу gcc есть и обратная сторона - он еще не принимает вариативные шаблоны, но это, возможно, уже исправлено, так как на моем компьютере не установлена ​​последняя версия boost.

Слава
источник
0

Я наткнулся на ту же проблему при переборе кортежа функциональных объектов, поэтому вот еще одно решение:

#include <tuple> 
#include <iostream>

// Function objects
class A 
{
    public: 
        inline void operator()() const { std::cout << "A\n"; };
};

class B 
{
    public: 
        inline void operator()() const { std::cout << "B\n"; };
};

class C 
{
    public:
        inline void operator()() const { std::cout << "C\n"; };
};

class D 
{
    public:
        inline void operator()() const { std::cout << "D\n"; };
};


// Call iterator using recursion.
template<typename Fobjects, int N = 0> 
struct call_functors 
{
    static void apply(Fobjects const& funcs)
    {
        std::get<N>(funcs)(); 

        // Choose either the stopper or descend further,  
        // depending if N + 1 < size of the tuple. 
        using caller = std::conditional_t
        <
            N + 1 < std::tuple_size_v<Fobjects>,
            call_functors<Fobjects, N + 1>, 
            call_functors<Fobjects, -1>
        >;

        caller::apply(funcs); 
    }
};

// Stopper.
template<typename Fobjects> 
struct call_functors<Fobjects, -1>
{
    static void apply(Fobjects const& funcs)
    {
    }
};

// Call dispatch function.
template<typename Fobjects>
void call(Fobjects const& funcs)
{
    call_functors<Fobjects>::apply(funcs);
};


using namespace std; 

int main()
{
    using Tuple = tuple<A,B,C,D>; 

    Tuple functors = {A{}, B{}, C{}, D{}}; 

    call(functors); 

    return 0; 
}

Вывод:

A 
B 
C 
D
тмарик
источник
0

Другой вариант - реализовать итераторы для кортежей. Это имеет то преимущество, что вы можете использовать различные алгоритмы, предоставляемые стандартной библиотекой, и циклы for на основе диапазона. Элегантный подход к этому объясняется здесь https://foonathan.net/2017/03/tuple-iterator/ . Основная идея заключается в том, чтобы превратить кортежи в ряд с begin()и end()методами для обеспечения итераторы. Сам итератор возвращает, std::variant<...>который затем можно посетить с помощью std::visit.

Вот несколько примеров:

auto t = std::tuple{ 1, 2.f, 3.0 };
auto r = to_range(t);

for(auto v : r)
{
    std::visit(unwrap([](auto& x)
        {
            x = 1;
        }), v);
}

std::for_each(begin(r), end(r), [](auto v)
    {
        std::visit(unwrap([](auto& x)
            {
                x = 0;
            }), v);
    });

std::accumulate(begin(r), end(r), 0.0, [](auto acc, auto v)
    {
        return acc + std::visit(unwrap([](auto& x)
        {
            return static_cast<double>(x);
        }), v);
    });

std::for_each(begin(r), end(r), [](auto v)
{
    std::visit(unwrap([](const auto& x)
        {
            std::cout << x << std::endl;
        }), v);
});

std::for_each(begin(r), end(r), [](auto v)
{
    std::visit(overload(
        [](int x) { std::cout << "int" << std::endl; },
        [](float x) { std::cout << "float" << std::endl; },
        [](double x) { std::cout << "double" << std::endl; }), v);
});

Моя реализация (которая во многом основана на пояснениях в приведенной выше ссылке):

#ifndef TUPLE_RANGE_H
#define TUPLE_RANGE_H

#include <utility>
#include <functional>
#include <variant>
#include <type_traits>

template<typename Accessor>
class tuple_iterator
{
public:
    tuple_iterator(Accessor acc, const int idx)
        : acc_(acc), index_(idx)
    {

    }

    tuple_iterator operator++()
    {
        ++index_;
        return *this;
    }

    template<typename T>
    bool operator ==(tuple_iterator<T> other)
    {
        return index_ == other.index();
    }

    template<typename T>
    bool operator !=(tuple_iterator<T> other)
    {
        return index_ != other.index();
    }

    auto operator*() { return std::invoke(acc_, index_); }

    [[nodiscard]] int index() const { return index_; }

private:
    const Accessor acc_;
    int index_;
};

template<bool IsConst, typename...Ts>
struct tuple_access
{
    using tuple_type = std::tuple<Ts...>;
    using tuple_ref = std::conditional_t<IsConst, const tuple_type&, tuple_type&>;

    template<typename T>
    using element_ref = std::conditional_t<IsConst,
        std::reference_wrapper<const T>,
        std::reference_wrapper<T>>;

    using variant_type = std::variant<element_ref<Ts>...>;
    using function_type = variant_type(*)(tuple_ref);
    using table_type = std::array<function_type, sizeof...(Ts)>;

private:
    template<size_t Index>
    static constexpr function_type create_accessor()
    {
        return { [](tuple_ref t) -> variant_type
        {
            if constexpr (IsConst)
                return std::cref(std::get<Index>(t));
            else
                return std::ref(std::get<Index>(t));
        } };
    }

    template<size_t...Is>
    static constexpr table_type create_table(std::index_sequence<Is...>)
    {
        return { create_accessor<Is>()... };
    }

public:
    static constexpr auto table = create_table(std::make_index_sequence<sizeof...(Ts)>{}); 
};

template<bool IsConst, typename...Ts>
class tuple_range
{
public:
    using tuple_access_type = tuple_access<IsConst, Ts...>;
    using tuple_ref = typename tuple_access_type::tuple_ref;

    static constexpr auto tuple_size = sizeof...(Ts);

    explicit tuple_range(tuple_ref tuple)
        : tuple_(tuple)
    {
    }

    [[nodiscard]] auto begin() const 
    { 
        return tuple_iterator{ create_accessor(), 0 };
    }

    [[nodiscard]] auto end() const 
    { 
        return tuple_iterator{ create_accessor(), tuple_size };
    }

private:
    tuple_ref tuple_;

    auto create_accessor() const
    { 
        return [this](int idx)
        {
            return std::invoke(tuple_access_type::table[idx], tuple_);
        };
    }
};

template<bool IsConst, typename...Ts>
auto begin(const tuple_range<IsConst, Ts...>& r)
{
    return r.begin();
}

template<bool IsConst, typename...Ts>
auto end(const tuple_range<IsConst, Ts...>& r)
{
    return r.end();
}

template <class ... Fs>
struct overload : Fs... {
    explicit overload(Fs&&... fs) : Fs{ fs }... {}
    using Fs::operator()...;

    template<class T>
    auto operator()(std::reference_wrapper<T> ref)
    {
        return (*this)(ref.get());
    }

    template<class T>
    auto operator()(std::reference_wrapper<const T> ref)
    {
        return (*this)(ref.get());
    }
};

template <class F>
struct unwrap : overload<F>
{
    explicit unwrap(F&& f) : overload<F>{ std::forward<F>(f) } {}
    using overload<F>::operator();
};

template<typename...Ts>
auto to_range(std::tuple<Ts...>& t)
{
    return tuple_range<false, Ts...>{t};
}

template<typename...Ts>
auto to_range(const std::tuple<Ts...>& t)
{
    return tuple_range<true, Ts...>{t};
}


#endif

Доступ только для чтения также поддерживается путем передачи const std::tuple<>&в to_range().

Флориан Тишлер
источник
0

Расширяя ответ @Stypox, мы можем сделать их решение более универсальным (начиная с C ++ 17). Добавив аргумент вызываемой функции:

template<size_t I = 0, typename... Tp, typename F>
void for_each_apply(std::tuple<Tp...>& t, F &&f) {
    f(std::get<I>(t));
    if constexpr(I+1 != sizeof...(Tp)) {
        for_each_apply<I+1>(t, std::forward<F>(f));
    }
}

Затем нам нужна стратегия для посещения каждого типа.

Начнем с некоторых помощников (первые два взяты из cppreference):

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
template<class ... Ts> struct variant_ref { using type = std::variant<std::reference_wrapper<Ts>...>; };

variant_ref используется, чтобы разрешить изменение состояния кортежей.

Использование:

std::tuple<Foo, Bar, Foo> tuples;

for_each_apply(tuples,
               [](variant_ref<Foo, Bar>::type &&v) {
                   std::visit(overloaded {
                       [](Foo &arg) { arg.foo(); },
                       [](Bar const &arg) { arg.bar(); },
                   }, v);
               });

Результат:

Foo0
Bar
Foo0
Foo1
Bar
Foo1

Для полноты картины вот мои Bar& Foo:

struct Foo {
    void foo() {std::cout << "Foo" << i++ << std::endl;}
    int i = 0;
};
struct Bar {
    void bar() const {std::cout << "Bar" << std::endl;}
};
Томас Легрис
источник