tuple and pack parameters

template <typename... Args>
class A
{
public:
    A(Args... args) {ind = std::make_tuple(args...);}
    std::tuple<Args...> ind;
};
 
void foo()
{
    std::cout << std::endl;
}
 
template <typename First, typename... Rest>
void foo(First _first, Rest... _rest)
{
    std::cout << _first;
    foo(_rest...);
}
 
 
int main()
{
    A a1(1, 2);
    A a2(1, 2, 3);
    A a3(1, 2, 3, 4);
 
    foo(a1.ind);
    foo(a2.ind);
    foo(a3.ind);
}

#include <tuple>
#include <iostream>
 
template <typename... Args>
class A
{
public:
    A(Args... args) {ind = std::make_tuple(args...);}
    std::tuple<Args...> ind;
};
 
void foo()
{
    std::cout << std::endl;
}
 
template <typename First, typename... Rest>
void foo(First _first, Rest... _rest)
{
    std::cout << _first;
    foo(_rest...);
}
 
 
int main()
{
    A a1(1, 2);
    A a2(1, 2, 3);
    A a3(1, 2, 3, 4);
 
    std::apply([](auto ...x){ foo(x...); }, a1.ind);
    std::apply([](auto ...x){ foo(x...); }, a2.ind);
    std::apply([](auto ...x){ foo(x...); }, a3.ind);
}

template <typename... Args>
class A
{
public:
    A(Args... args) {ind = std::make_tuple(args...);}
    std::tuple<Args...> ind;
};
 
void foo()
{
    std::cout << std::endl;
}
 
template <typename First, typename... Rest>
void foo(First _first, Rest... _rest)
{
    std::cout << _first;
    foo(_rest...);
}
 
template< size_t ... Ints >
class integer_sequence{};
 
 
template < typename T, size_t N >
struct add_sequence;
 
template < size_t N, size_t ... IDX >
struct add_sequence< integer_sequence<IDX...>, N>
{
    using type = integer_sequence< IDX..., N>;
};
 
template < size_t N >
struct sequence_helper
{
    using type = typename add_sequence< typename sequence_helper<N-1>::type, N-1>::type;
};
 
template<>
struct sequence_helper<0>
{
    using type = integer_sequence<>;
};
 
template<size_t N>
using make_integer_sequence = typename sequence_helper<N>::type;
 
template < typename IS, typename TUPPLE >
struct call;
 
template < size_t ... IDX, typename ... PARMS >
struct call< integer_sequence< IDX...>, std::tuple< PARMS...>>
{
    static void go( std::tuple< PARMS...> parms )
    {
        foo( std::get< IDX >( parms ) ... );
    }
};
 
template < typename ... PARMS >
void foo2( std::tuple< PARMS...>& tup )
{
    call<make_integer_sequence< sizeof...(PARMS)>, std::tuple< PARMS...>>::go( tup );
}
 
 
int main()
{
    A<int, int> a1(1, 2);
    A<int, int, int> a2(1, 2, 3);
    A<int, int, int, int> a3(1, 2, 3, 4);
 
    foo2(a1.ind);
    foo2(a2.ind);
    foo2(a3.ind);
}

#include <tuple>
#include <iostream>
 
template <typename... Args>
class A
{
public:
    A(Args... args) {ind = std::make_tuple(args...);}
    std::tuple<Args...> ind;
};
 
 
template<typename T>
void output(T const & v)
{
    std::cout << v;
}
 
template<typename ... Args, size_t ... Indexes>
void output_tuple(std::tuple<Args...> const & t, std::index_sequence<Indexes...>)
{
    int fake[] = 
    {
        (output(std::get<Indexes>(t)), 0)...
    };
    (void)fake;//make happy
}
 
template<typename ... Args>
void output(std::tuple<Args...> const & v)
{
    output_tuple(v, std::make_index_sequence<sizeof...(Args)>());
}
 
void foo()
{
    std::cout << '\n';
}
 
template <typename First, typename... Rest>
void foo(First _first, Rest... _rest)
{
    output(_first);
    foo(_rest...);
}
 
 
 
int main()
{
    A a1(1, 2);
    A a2(1, 2, 3);
    A a3(1, 2, 3, 4);
 
    foo(a1.ind);
    foo(a2.ind);
    foo(a3.ind);
}