test-cpp


#include <iostream>
#include <vector>

using namespace std;

int foo(int i) {
return i + 1;
}

int bar(int i) {
return i * 10;
}

typedef int(FP) (int);

int proccess(FP *fp, int i) {
int r = (*fp)(i);
cout << r << endl;
return r;
}

// the basic one
class CompInt {
typedef int(*_FP)(int);
public:
CompInt(_FP f, _FP g) : fp(f), gp(g){}
int operator() (int _i) {
return (*fp)((*gp)(_i));
}
private:
_FP fp;
_FP gp;
};

// template but need to specify the FOUR parameter types
/*
template<class F, class G, class X, class Y> class Comp {
public:
Comp(F f0, G g0): f(f0), g(g0) {}
Y operator() (X x) const {
return f(g(x));
}
private:
F f;
G g;
};
*/

// the COMMON template function object
template<class X, class Y> class Comp_base {
public:
virtual Y operator() (X) const = 0;
virtual Comp_base* clone() const = 0;
virtual ~Comp_base() {}
};

template<class F, class G, class X, class Y> class CompCommon: public Comp_base<X, Y> {
public:
CompCommon(F f0, G g0): f(f0), g(g0) { }
Y operator() (X x) const {
return f(g(x));
}
Comp_base<X, Y>* clone() const {
return new CompCommon(*this);
}
private:
F f;
G g;
};

template<class X, class Y> class Composition {
public:
template<class F, class G> Composition(F, G);
Composition(const Composition&);
Composition& operator = (const Composition&);
~Composition();
Y operator() (X) const;
private:
Comp_base<X, Y>* p;
};

template<class X, class Y>
template<class F, class G>
Composition<X, Y>::Composition(F f, G g) : p(new CompCommon<F, G, X, Y>(f, g)) {};

template<class X, class Y>
Composition<X, Y>::~Composition() {
delete p;
}

template<class X, class Y>
Composition<X, Y>::Composition(const Composition& c) : p(c.p->clone()) { }

template<class X, class Y>
Composition<X, Y>& Composition<X, Y>::operator = (const Composition& c) {
if(this != &c) {
delete p;
p = c.p->clone();
}
return *this;
}

template<class X, class Y>
Y Composition<X, Y>::operator ()(X x) const {
return (*p)(x);
}

int main() {
// proccess(bar, proccess(foo, 1));
cout << CompInt(foo, bar)(10) << endl;

/*
Comp<int (*)(int), int(*)(int), int, int> fg(foo, bar);
cout << fg(1) << endl;
*/


Composition<int, int> fg2(foo, bar);
cout << fg2(1) << endl;

return 0;
}