5

所以我一直在尝试使用可变参数模板从更方便的子类型中组合对象，但我无法让它完全按照我的意愿去做。

template<class ...Functor>
struct SeqMethod:public Functor...{
  template<class F>
  void call(F& a){
    F::operator()();
  }
  template<class F,class ... funcs>
  void call(){
    F::operator()();

    call<funcs...>();
  }
  public:
  void operator()(){
    call<Functor...>();
  }
};

这不是有效的语法，所以就是这样。

理想情况下，我希望能够使用这样的东西

class A{
public:
  void operator()(){
    std::cout<<"A";
  }
};
class B{
public:
  void operator()(){
    std::cout<<"B";
  }
};

class C:public SeqMethod<A,B>{};

在这种情况下应该输出“AB”，并且通常适合组合行为。

4

2 回答 2

6

在您的情况下，您实际上不需要任何call成员函数。
相反，您可以在 C++11/C++14 中执行此操作：

template<class ...Functor>
struct SeqMethod:public Functor...{
  public:
  void operator()(){
      int _[] = { (Functor::operator()(), 0)... };
      return void(_);
  }
};

它遵循一个最小的工作示例：

#include<iostream>

template<class ...Functor>
struct SeqMethod:public Functor...{
  public:
  void operator()(){
    int _[] = { (Functor::operator()(), 0)... };
    return void(_);
  }
};

class A{
public:
  void operator()(){
    std::cout<<"A";
  }
};
class B{
public:
  void operator()(){
    std::cout<<"B";
  }
};

class C:public SeqMethod<A,B>{};

int main() {
  C c;
  c();
}
于 2016-12-23T23:50:23.453 回答
3

最简单的方法是使用 C++17 的折叠表达式：

template<class ...Functor>
struct SeqMethod:public Functor...{

 public:
    void operator()(){
        (Functor::operator()(),...);
    }
};

class A{
public:
    void operator()(){
        std::cout<<"A";
    }
};
class B{
public:
    void operator()(){
        std::cout<<"B";
    }
};

class C:public SeqMethod<A,B>{};

int main()
{
    C c;
    c();
    return 0;
}

输出（使用 gcc 6.2 测试）：

AB
于 2016-12-23T23:50:31.877 回答