8

在 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() 函数的调用顺序是从左到右的，但这并不重要。

4

3 回答 3

4

这应该有效：

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其作为 a传递，void*但这可能会很麻烦，所以我只是在其中添加了一个额外的模板参数recinitwill be Foo。

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

于 2013-03-08T14:17:57.330 回答
3

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

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
}
于 2013-03-08T14:18:55.403 回答
2

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

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

你已经处理了F，把它从参数列表中去掉。

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

（此外，您可能应该完美地转发论点。）

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

于 2013-03-08T14:38:26.010 回答