Question

基本上，我想要做的是在一些抽象类上使用包装器，然后使用相同的包装器类包装该类的任何成员函数的输出。继续这样做，以便始终包裹所有对象。

喜欢（presudocode）

wrap<set(1..10)> (multiply,2)
                 (divide,3)
                 (plus,5)
                 (inverse)
                 (collect first 10)
                .unwrap()

除了最后一行之外的所有行都输出了一些内容。现在似乎意味着更少，但我相信我们可以在其上应用有趣的东西，如：

wrap<someClass> dat;
dat.splitIntoThreads(2)
    (thingA)    .clone()
    (thingB)    (thing1)
    (thingC)    (thing2)
    (thingD)    (thing3)
    .nothing()  (thing4)
    .sync()     .exit()
    .addMerge()

这是我的换行代码：

template<class T>
struct wrap{
  wrap(){}
  wrap(T b){a=b;}
  template<class L,class...R>
  L operator() (L(T::*f)(R...),R...r){
    return a.f(r...);
  }
  T a;
};

int main(){
  wrap<testClass> a;
  a(&testClass::f,13,'a');
}

它正在工作（gcc，c ++ 0x）。但是当我用以下内容替换第6,7行时（实际包装结果）

wrap<L> operator() (L(T::*f)(R...),R...r){
  return wrap<L>(a.f(r...));

编译器只是sais：创建指向非类型“int”的成员函数的指针。

我该如何解决这个问题？有没有比这更好的了？继承是一种方式，但由于我们可能在一个包装中有变量实例，我认为它没用。

修改

这是我的测试类

struct testClass{
  int f(int a,char b){
    return a+b;
  }
};

我使用wrap L而不是wrap T的原因是返回类型可能不总是T。

Answer 1

您可以尝试这样的事情：

#include <iostream>
#include <type_traits>

template<class T, bool = false>
struct wrap{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {};
  template<class L, class...R>
  wrap<L,std::is_fundamental<L>::value> operator() (L(T::*f)(R...),R...r){
    return wrap<L,std::is_fundamental<L>::value > {(a.*f)(r...)};
  }
  T a;
};

template<class T>
struct wrap <T,true>{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {}
  template<class L, class...R>
  wrap<L,std::is_fundamental<L>::value> operator() (L(*f)(T a, R...), R...r){
      return wrap<L,std::is_fundamental<L>::value > {f(a, r...)};
  }
  T a;
};

class testClass {
    int m;
public:
testClass(int _m) : m{_m}{}
    int multiAdd(int x, char y) {
        m += x + y;
        return m;
    }
};

int add(int a, char b)
{
    return a+b;
}

int main(){
  wrap<testClass> a{0};
  std::cout << a(&testClass::multiAdd,0,'d')(add,'a').a<<std::endl;

  wrap<int, true> b{3};
  std::cout << b(add,'a').a<<std::endl;
}

cpp.sh/6icg

Answer 2

似乎错误出现在testclass定义中。请查看以下示例。

另外，在operator（）中包装可以作为参考返回。我没有看到任何需要创建用于（）链接的临时工具。

template<class T>
struct wrap{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {};

  template<class L, class...R>
  wrap<T>& operator() (L(T::*f)(R...),R...r){
    a.f(r...);
    return *this; //returning reference to current wrap object.
  }
  T a;
};

用于累积数字的测试类。

class testClass {
    int m;
public:
testClass(int _m) : m{_m}{}
    int f(int x) {
        m += x;
        std::cout << ' ' << m;
        return m;
    }
};

一个用法示例：

int main(){
  wrap<testClass> a{0};
  a(&testClass::f,13)(&testClass::f, 11)(&testClass::f,3)(&testClass::f, 21);
}

每一步积累的总和的输出：

13 24 27 48

如何编写一个不断敲击输出的包装器？

2 个答案: