Me gustaría poder hacer esto:

template<typename Mix>
struct A {
  A(int i) { }
};

template<typename Mix>
struct B {
  B() { }
  B(const char*) { }
};

template<template<typename> class... Mixins>
struct Mix : Mixins<Mix<Mixins...>>... {
   // This works, but forces constructors to take tuples
   template<typename... Packs>
   Mix(Packs... packs) : Packs::Type(packs.constructorArgs)... { }
};

template<template<typename> class MixinType, typename... Args>
struct ArgPack {
  typedef MixinType Type; // pretend this is actually a template alias
  tuple<Args...> constructorArgs;
  ArgPack(Args... args) : constructorArgs(args...) { }
}

template<typename... Args>
ArgPack<A, Args...> A_(Args... args) {
  return ArgPack<A, Args...>(args...);
}

template<typename... Args>
ArgPack<B, Args...> B_(Args... args) {
  return ArgPack<B, Args...>(args...);
}

Mix<A, B> m(); // error, A has no default constructor

Mix<A, B> n(A_(1)); // A(int), B()
Mix<A, B> n(A_(1), B_("hello"); // A(int), B(const char*)

¿Cómo rellenar / * código misterioso aquí * / para hacer lo que quiero, para proporcionar una interfaz agradable para llamar a un conjunto de constructores de mixins? Tengo una solución que funciona haciendo que todas las construcciones no nulas realmente tomen una tupla de argumentos, y luego sobrecargue las cifras a las que llamar, pero me gustaría evitar restringir a los autores mixin al hacer que escriban un constructor A (tupla), en lugar de solo A (int, int).

¡Gracias