Переадресация вызовов базового класса с вариативным шаблоном

Это должно работать:

template<typename F, typename... T>
    struct recinit;

template<typename F>
    struct recinit<F> {
        static bool tinit(F *) {
            return true;
        }
    };
template<typename F, typename T, typename... G>
    struct recinit<F, T, G...> {
        static bool tinit(F *ptr)  {
            if (!ptr->T::init())
                return false;
            return recinit<F, G...>::tinit(ptr);
        }
    };

template<typename... Features>
struct Foo : Features... {

    bool init() {
        bool res = recinit<Foo, Features...>::tinit(this);
        //use res wisely
    }
};

Ваша проблема в том, что вы не можете писать частичные специализации функций, только классов / структур. И вспомогательная структура должна находиться за пределами Foo, иначе она получит аргументы шаблона из включающей структуры, и это было бы плохо.

Вы не говорите, но я предполагаю, что init - нестатическая функция-член. В таком случае args аргументы не имеют смысла: все они должны быть this! Так что просто пропустите это один раз и избегайте пачки аргументов. Я попытался передать this как void*, но это может вызвать проблемы, поэтому я просто добавил дополнительный аргумент шаблона в recinit, который будет Foo.

Кроме того, каждый раз, когда вы делаете один рекурсивный шаг, не забудьте удалить один параметр.

Может быть, вы могли бы попробовать что-то вроде этого:

template<typename... Features>
struct Foo : Features...
{
    bool init()
    {
        // Courtesy of Xeo :-)
        auto il = {(static_cast<bool (Foo::*)()>(&Features::init))...};
        return std::all_of(il.begin(), il.end(), 
            [this] (bool (Foo::*f)()) { return (this->*f)(); }
            );
    }
};

Вот альтернативная, более подробная версия, в которой используются вариативные шаблоны:

template<typename... Features>
struct Foo : Features...
{
    bool init()
    {
        return combine_and((&Features::init)...);
    }

private:

    bool combine_and()
    {
        return true;
    }

    template<typename F>
    bool combine_and(F f)
    {
        return (this->*f)();
    }

    template<typename F1, typename... Fs>
    bool combine_and(F1 f1, Fs... fs)
    {
        return ((this->*f1)() && combine_and(fs...));
    }
};

Какое бы решение вы ни выбрали, вы можете использовать его следующим образом:

#include <iostream>

using namespace std;

struct A { bool init() { cout << "Hello " << endl; return true; } };
struct B { bool init() { cout << "Template " << endl; return true; } };
struct C { bool init() { cout << "World!" << endl; return true; } };

int main()
{
    Foo<A, B, C> f;
    bool res = f.init(); // Prints "Hello Template World!"
    cout << res; // Prints 1
}

У вашего кода две проблемы. Во-первых, довольно обыденное:

return recinit<F,G...>(args...);

Вы уже работали с F, не включайте его в список аргументов.

return recinit<G...>(args...);

(Кроме того, вам, вероятно, следует точно пересылать аргументы.)

Во-вторых, код не будет компилироваться, потому что ваша рекурсия имеет привязку во время выполнения , но не во время компиляции. То есть компилятор попытается распаковать пакет аргументов G до бесконечности. Чтобы предотвратить это, вам необходимо специализировать функцию для пустого списка аргументов шаблона.