How to write a wrapper that continues to tear out?

Question

Basically, I want to make a hava wrapper in some abstract class, and then include the same wrapper class around the output of any member function of this class. Continue to do this so that all objects are always wrapped.

How (overcodes)

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

All lines except the last line output something. At the moment, this will seem less, but I believe that we can apply interesting things to it, for example:

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

Here is my transfer code:

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');
}

Works (gcc, C ++ 0x). But when I replace the 6,7th line with the following (to actually wrap the result)

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

The compiler is simply sais: creates a pointer to a member function of a non-class class of type "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. , .

, wrap 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