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



construct array by nodefault class

Just a test for pretty.js :)

#include
#include
using namespace std;

class NoDefault {
friend ostream& operator << (ostream& os, const NoDefault& o);
private:
static unsigned _id;
unsigned id;
unsigned pid;
public:
NoDefault(char ch){
id = ++_id;
pid = 0;
cout << "NoDefault(char): " << id << endl;
}
NoDefault(const NoDefault& o) {
id = ++_id;
pid = o.id;
cout << "NoDefault(const NoDefault&): " << id << " by pid: " << o.id << endl;
}

};

unsigned NoDefault::_id = 0;

ostream& operator << (ostream& os, const NoDefault& o) {
os << "id: " << o.id << ";\tpid: " << o.pid;
return os;
}

int main() {
//! NoDefault o0; // error
NoDefault o1('1');
NoDefault o2(o1);

// cannot initialize array
//! NoDefault os0[10];

vector v0;
v0.push_back(o1);

cout << "vector<> v(n, c)" << endl;
//! vector v1(10);
vector v2(10, NoDefault('1'));

// malloc & new
//! NoDefault *op1 = new NoDefault[10];

// malloc space for 10 NoDefault objects, but not initialize it.
NoDefault *op2 = (NoDefault*)malloc(sizeof(NoDefault) * 10);
new(op2 + 1) NoDefault('c'); // initilize op2[1]
cout << op2[1] << endl;
cout << op2[0] << endl; // op2[0] is not initialized
return 0;
}