1#include <tuple>
2#include <iostream>
3
4int main()
5{
6 std::tuple t{42, 'a', 4.2}; // Another C++17 feature: class template argument deduction
7 std::apply([](auto&&... args) {((std::cout << args << '\n'), ...);}, t);
8}
9
1{
2 auto tup = std::make_tuple(0, 'a', 3.14);
3 template for (auto elem : tup)
4 std::cout << elem << std::endl;
5}
6
1#include <tuple>
2#include <utility>
3
4template<std::size_t N>
5struct tuple_functor
6{
7 template<typename T, typename F>
8 static void run(std::size_t i, T&& t, F&& f)
9 {
10 const std::size_t I = (N - 1);
11 switch(i)
12 {
13 case I:
14 std::forward<F>(f)(std::get<I>(std::forward<T>(t)));
15 break;
16
17 default:
18 tuple_functor<I>::run(i, std::forward<T>(t), std::forward<F>(f));
19 }
20 }
21};
22
23template<>
24struct tuple_functor<0>
25{
26 template<typename T, typename F>
27 static void run(std::size_t, T, F){}
28};
29
1std::apply([](auto ...x){std::make_tuple(x.do_something()...);} , the_tuple);
2
1#include <tuple>
2#include <iostream>
3#include <boost/hana.hpp>
4#include <boost/hana/ext/std/tuple.hpp>
5
6struct Foo1 {
7 int foo() const { return 42; }
8};
9
10struct Foo2 {
11 int bar = 0;
12 int foo() { bar = 24; return bar; }
13};
14
15int main() {
16 using namespace std;
17 using boost::hana::for_each;
18
19 Foo1 foo1;
20 Foo2 foo2;
21
22 for_each(tie(foo1, foo2), [](auto &foo) {
23 cout << foo.foo() << endl;
24 });
25
26 cout << "foo2.bar after mutation: " << foo2.bar << endl;
27}
28
1template <size_t ...I>
2struct index_sequence {};
3
4template <size_t N, size_t ...I>
5struct make_index_sequence : public make_index_sequence<N - 1, N - 1, I...> {};
6
7template <size_t ...I>
8struct make_index_sequence<0, I...> : public index_sequence<I...> {};
9
1// prints every element of a tuple
2template<size_t I = 0, typename... Tp>
3void print(std::tuple<Tp...>& t) {
4 std::cout << std::get<I>(t) << " ";
5 // do things
6 if constexpr(I+1 != sizeof...(Tp))
7 print<I+1>(t);
8}
9