initializing std::tuple which element constructors require object from another std::tuple

Question

consider the following code

template<typename T> struct B;
template<typename T> struct C;

template<typename...As>
struct A
{
   typedef std::tuple< B<As> ...> Bs;
   typedef std::tuple< C< B<As> >...> Cs;

   Bs m_Bs; 
   Cs m_Cs;

    A() :  
    m_Bs(B<As(someargs)...),
    m_Cs(????...)
   {}

};

How should I initialize m_Cs if I need to initialize std::get<n>(m_Cs) with std::get<n>(m_Bs) i.e. constructor of each element in m_Cs requires a corresponding element from m_Bs

Answer 1

How should I initialize m_Cs if I need to initialize std::get<n>(m_Cs) with std::get<n>(m_Bs) i.e. constructor of each element in m_Cs requires a corresponding element from m_Bs

I suppose you can use a delegating constructor with the help of std::index_sequence/std::index_sequence_for

Something as follows

  template <std::size_t ... Is>
  A (std::index_sequence<Is...> const &, As const & ... args)
     : m_Bs{B<As>{args}...}, m_Cs{std::get<Is>(m_Bs)...}
   { }

  A (As const & ... args)
     : A{std::index_sequence_for<As...>{}, args...}
   { }

The following is a full compiling example

#include <tuple>
#include <type_traits>

template <typename T>
struct B
 { B (T const &) {} };

template <typename T>
struct C
 { C (T const &) {} };

template <typename ... As>
struct A
 {
   private: 
      using Bs = std::tuple<B<As>...>;
      using Cs = std::tuple<C<B<As>>...>;

      Bs m_Bs; 
      Cs m_Cs;

      template <std::size_t ... Is>
      A (std::index_sequence<Is...> const &, As const & ... args)
         : m_Bs{B<As>{args}...}, m_Cs{std::get<Is>(m_Bs)...}
       { }

   public:
      A (As const & ... args)
         : A{std::index_sequence_for<As...>{}, args...}
       { }
 };

int main()
 {
   A<int, long, long long> a{1, 2L, 3LL};
 }