#include <iostream>

using namespace std;

// макрос для вывода "что я за функция?"
#define WHOAMI() (cout << __FUNCSIG__ << endl)

// шаблонные параметры шаблона - 1-3-арные шаблоны
#define UNARY template<class>class
#define BINARY template<class,class>class
#define TERNARY template<class,class,class>class

// генератор классов для нашей иерархии
template<class V> struct define
{
    void f(V) { WHOAMI(); }
    void g(V) { WHOAMI(); }
    void h(V) { WHOAMI(); }
    void p()  { WHOAMI(); }
};

// создадим базовые классы
// (можно было using A = define<int>, но это сделало бы отладочный вывод ещё менее читаемым)
struct A : define<int> {};
struct B : define<char> {};
struct C : define<float> {};
struct D : define<double> {};

// генератор миксина, объявляющего using членов
#define DEFINE_USING(mixin, member) \
    template<class Base, class X, class Y> struct mixin : Base { using X::member; using Y::member; }; \
    template<class Base, class X> struct mixin<Base,X,X> : Base { using X::member; }; \
    //endmacro

// перечислим интересующие нас члены
DEFINE_USING(using_f, f)
DEFINE_USING(using_g, g)
DEFINE_USING(using_h, h)
DEFINE_USING(using_p, p)
DEFINE_USING(using_q, q) // добавим один несуществующий член - это же просто имя!

// генератор плоской иерархии
template<class... Bases> struct inherit : Bases... {};

// свёртка миксином набора баз (пример левой свёртки)
template<TERNARY mixin> struct apply_mixin_l_impl
{
    template<class Base, class... Xs> struct run;

    template<class Base> struct run<Base>
    {
        using result = Base;
    };
    template<class Base, class X> struct run<Base, X>
    {
        using result = mixin<Base,X,X>;
    };
    template<class Base, class X, class Y> struct run<Base, X,Y>
    {
        using result = mixin<Base,X,Y>;
    };
    template<class Base, class X, class Y, class... Zs> struct run<Base, X,Y,Zs...>
    {
        // левая свёртка
        using tmp = mixin<Base,X,Y>;
        using result = typename run<tmp,tmp,Zs...>::result;
    };
};
template<class Base, TERNARY mixin, class... Xs> using apply_mixin_l = typename apply_mixin_l_impl<mixin>::template run<Base,Xs...>::result;

// (пример правой свёртки)
template<class Base, TERNARY mixin> struct apply_mixin_r_impl
{
    template<class... Xs> struct run // определение для случая <>
    {
        using result = Base;
    };
    template<class X> struct run<X>
    {
        using result = mixin<Base,X,X>;
    };
    template<class X, class Y> struct run<X,Y>
    {
        using result = mixin<Base,X,Y>;
    };
    template<class X, class... Ys> struct run<X,Ys...>
    {
        using folded = typename run<Ys...>::result;
        using result = mixin<folded,X,folded>;
    };
};
template<class Base, TERNARY mixin, class... Xs> using apply_mixin_r = typename apply_mixin_r_impl<Base,mixin>::template run<Xs...>::result;

// определимся, что будем использовать левую свёртку
template<class Base, TERNARY mixin, class... Xs> using apply_mixin = apply_mixin_l<Base,mixin,Xs...>;

// пример выборочного доступа к функциям
using E0 = inherit<A,B,C,D>;
using E1 = apply_mixin<E0, using_q>; // у нас нет баз с членом q, но это не должно нам помешать!
//using Efail = apply_mixin<E0, using_q, A>; // попытка сделать using A::q вызовет ошибку компиляции
using Ep = apply_mixin<E1, using_p, D>; // если заявим несколько баз, получим неоднозначность
using Ef = apply_mixin<Ep, using_f, A,B,C,D>;
using Efg = apply_mixin<Ef, using_g, A,C>; // выбор между g(int) и g(float)
using Efgh = apply_mixin<Efg, using_h, B,D>; // выбор между h(char) и h(double)

// композиция миксинов
template<class Base, class X, class Y> struct compose_mixins_impl
{
    template<TERNARY... Ms> struct run;

    //template<> struct run<> // так нельзя, С++11 и 14 запрещают явную специализацию
    template<TERNARY... Ms> struct run  // поэтому для случая <> сделаем реализацию в основном шаблоне
    {
        using result = Base;
    };
    template<TERNARY M> struct run<M>
    {
        using result = M<Base,X,Y>;
    };
    template<TERNARY M, TERNARY... Ms> struct run<M,Ms...>
    {
        using folded = typename run<Ms...>::result;
        using result = M<folded,X,Y>;
    };
};
template<TERNARY... Ms> struct compose_mixins
{
    template<class Base, class X, class Y> using mixin = typename compose_mixins_impl<Base,X,Y>::template run<Ms...>::result;
};

// чтобы дать имя шаблону, приходится указать его параметры и передать их в "вычисленный" шаблон
template<class Base, class X, class Y> using using_fgh = typename compose_mixins<using_f, using_g, using_h>::template mixin<Base,X,Y>;

// наследник, в котором все члены вытащены для всех баз
using Eall = apply_mixin<Ep, using_fgh, A,B,C,D>;

// наконец, давайте сконструируем всё вместе.
// для этого нам понадобится перечислить сразу два variadic-набора
template<class...> struct list_bases {};
template<TERNARY...> struct list_mixins {};

template<class ListBases, class ListMixins> struct install_impl;
template<class... Bs, TERNARY... Ms> struct install_impl<list_bases<Bs...>, list_mixins<Ms...>>
{
    using base = inherit<Bs...>;
    template<class B, class X, class Y> using mixin = typename compose_mixins<Ms...>::template mixin<B,X,Y>;
    using result = apply_mixin<base, mixin, Bs...>;
};
template<class ListBases, class ListMixins> using install = typename install_impl<ListBases,ListMixins>::result;

using Einst = install< list_bases<A,B,C,D>, list_mixins<using_f,using_g,using_h> >;
using Etotal = apply_mixin<Einst, using_p, D>;

// далее мы можем наследоваться от сконструированных наследников
struct Ffgh : Efgh {};
struct Fall : Eall {};
struct Ftotal : Etotal {};

// тестовая функция
template<class E>
void run()
{
    WHOAMI();
    cout << endl;
    E e;
    e.f(1);
    e.g('1');
    e.h(1.f);
    e.p();
    cout << endl << endl;
}

int main()
{
    run<Efgh>();
    run<Eall>();
    run<Etotal>();

    run<Ffgh>();
    run<Fall>();
    run<Ftotal>();
}