Question

I was writing some code where I have a class that can accept mixins as variadic template parameters. However, I also need the mixins to be able to access the base class through the CRTP idiom. Here’s a minimal example that cannot quite do what I want:

template <template <class> class... Mixins>
class Foo : Mixins<Foo<Mixins...>>... {};

However, a mixin that I might pass to Foo will, in general, have several template parameters, like so:

template <class Derived, class Type1, class Type2>
class Bar
{
    Derived& operator()()
    {
        return static_cast<Derived&>(*this);
    }
};

How can I change Foo so that I can have it inherit from a number of base classes, where I control the template parameters accepted by each base class? If I hand Foo a list of template-template parameters, along with a list of arguments to pass to them, then I don’t see how I would be able to associate each template-template parameter with its arguments. So far, I thought of something like this, but I don’t know how I would proceed.

template <template <class...> class T,
    template <class...> class... Ts>
class Foo : /* How do I retrieve the arguments? */

Answer 1

I am not quite sure I understood the problem, so please let me rephrase it so that we can start on the right foot.

You need to thread the derived type to the base classes, in a typical CRTP use case, while at the same time passing other template parameter to the various base classes.

That is, a typical base class will be:

template <typename Derived, typename X, typename Y>
struct SomeBase {
};

And you want need to create your type so that you can control the X and Y and at the same time pass the complete Derived class.

---

I think I would use the apply trick to generate the base class on the fly, from an adapter provided in the argument list of the Derived class.

template <typename Derived, typename X, typename Y>
struct SomeBase {};

template <typename X, typename Y>
struct SomeBaseFactory {
  template <typename Derived>
  struct apply { typedef SomeBase<Derived, X, Y> type; };
};

// Generic application
template <typename Fac, typename Derived>
struct apply {
  typedef typename Fac::template apply<Derived>::type type;
};

Then, you would create the type as:

typedef MyFoo< SomeBaseFactory<int, float> > SuperFoo;

Where Foo is defined as:

template <typename... Args>
struct Foo: apply<Args, Foo<Args...>>::type... {
};

And just because it’s been a while since I trudged so deeply in templates, I checked it worked.

---

Of course, the Factory itself is not really a specific to a given type, so we can reuse the wrapper approach you had experimented:

template <template <typename...> class M, typename... Args>
struct Factory {
  template <typename Derived>
  struct apply { typedef M<Derived, Args...> type; };
};

And yes, it works too.