Question

在11 C ++之前，我有类似的东西：

template<class T,class U,class V>
struct Foo : T,U,V {

  bool init() {

    if(!T::init() || !U::init() || !V::init())
      return false;

    // do local init and return true/false
  }
};

我想将其转换为C ++ 11可变参数语法，以获得灵活长度参数列表的好处。我理解使用递归解压缩模板arg列表的概念，但我无法看到正确的语法。这是我尝试过的：

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

  template<typename F,typename... G>
  bool recinit(F& arg,G&& ...args) {

    if(!F::init())
      return false;

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

  bool init() {
    // how to call recinit() from here?
  }
};

我更希望调用基类init（）函数的顺序是从左到右，但它并不重要。

Answer 1

这应该有效：

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。

而且，每次执行一个递归步骤时，请记住删除一个参数。

Answer 2

也许你可以尝试这样的事情：

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
}

Answer 3

您的代码有两个问题。首先，相当平凡：

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

您已经处理过F，将其从参数列表中删除。

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

（另外你应该完美地转发论点。）

其次，代码将无法编译，因为您的递归在运行时但在编译时没有锚。也就是说，编译器将尝试无限地解包参数包G。为了防止这种情况，您需要专门化空模板参数列表的函数。

Variadic模板基类调用转发

3 个答案: