Part 1: print std::array with std::integer_sequence
Part 2: convert tuple to parameter pack
Part 3: print std::array with std::apply and fold
Part 4: fold over std::tuple und erzeugten Assembler Code
Part 5: fold over std::tuple of std::vector of Types ...
Part 6: apply generic lambda to tuple
Part 7: Play with std::tuple and std::apply
Okay das ist ein seltsames Konstrukt. Wir haben viele Instanzen vieler Typen über die alle zusammen iteriert wird. Eigentlich ist der Code ziemlich klar. Ansonsten.... WOW was alles mit C++17 geht.
#include <type_traits>
#include <tuple>
#include <vector>
#include <iostream>
template<typename... Args>
struct A : std::tuple<std::vector<Args>...>
{
template<typename T>
void add(const T&x) {
std::get<std::vector<T>>(*this).push_back(x);
}
};
namespace std {
template<typename...Args>
struct tuple_size<A<Args...>> : std::integral_constant<std::size_t, sizeof...(Args)> {};
}
auto func() {
A<int,double> a;
a.add(1);
a.add(2);
a.add(10.1);
a.add(20.1);
return a;
}
template<typename T>
std::ostream& operator<<(std::ostream& s, const std::vector<T>& vec) {
for(const auto& x : vec) {
s << x << ' ';
}
return s;
}
void func3() {
auto a = func();
std::apply([&](const auto&...vectors){ (std::cout << ... << vectors); }, a);
}