I have the following sample program, which can convert function object
with 1 argument into function object with 2 arguments. It can also do +
between function object of the same type.
The last line is very long. I'm wondering if there is any way to
suppress it. I can only think of typedef. But I'm not sure whether I
can use typedef for the return type.
Would you please help me? Please don't be daunted by the length of the
code.
Thanks,
Peng
/*main.cc*/
#include "expression_tem plates.h"
#include <cassert>
#include <complex>
int main(void) {
sample_1_arg_fu n<std::complex< double> > f;
std::cout << cast1stArg(f)(0 , 1) << std::endl;
std::cout << cast2ndArg(f)(0 , 1) << std::endl;
std::cout << (cast2ndArg(f) + cast2ndArg(f))( 2, 1) << std::endl;
}
/*expression_tem plates.h*/
#include <iostream>
#include <functional>
#include <algorithm>
#include <limits>
template <typename T>
class sample_1_arg_fu n {
public:
typedef T return_type;
return_type operator()(int i) const { return (i>= the_min_limit()
&& i <= the_max_limit() )?i:0; }
int the_min_limit() const { return std::numeric_li mits<int>::min( );
}
int the_max_limit() const { return std::numeric_li mits<int>::max( );
}
};
struct LimitsUnion {
int min_limit(int min_limit1, int min_limit2) const { return
std::min(min_li mit1, min_limit2); }
int max_limit(int max_limit1, int max_limit2) const { return
std::max(max_li mit1, max_limit2); }
};
struct LimitsIntersect ion {
int min_limit(int min_limit1, int min_limit2) const { return
std::max(min_li mit1, min_limit2); }
int max_limit(int max_limit1, int max_limit2) const { return
std::min(max_li mit1, max_limit2); }
};
template <typename BinOp>
struct BinOpTraits;
template <typename T>
struct BinOpTraits<std ::plus<T> >{
typedef LimitsUnion limit_op;
};
template <typename T1, typename ExprT1, typename T2, typename ExprT2,
typename BinOp>
class Expr2Args;
template <typename T, typename ExprT>
class Expr2Args<T, ExprT, void, void, void> {
public:
typedef T return_type;
Expr2Args(const ExprT e) : _e(e) {}
return_type operator()(int i1, int) const { return _e(i1); }
int the_1st_min_lim it() const { return e.the_min_limit (); }
int the_1st_max_lim it() const { return e.the_max_limit (); }
int the_2nd_min_lim it() const { return
std::numeric_li mits<int>::min( ); }
int the_2nd_max_lim it() const { return
std::numeric_li mits<int>::max( ); }
private:
const ExprT _e;
};
template <typename T, typename ExprT>
class Expr2Args<void, void, T, ExprT, void> {
public:
typedef T return_type;
Expr2Args(const ExprT e) : _e(e) {}
return_type operator()(int, int i2) const { return _e(i2); }
int the_1st_min_lim it() const { return
std::numeric_li mits<int>::min( ); }
int the_1st_max_lim it() const { return
std::numeric_li mits<int>::max( ); }
int the_2nd_min_lim it() const { return e.the_min_limit (); }
int the_2nd_max_lim it() const { return e.the_max_limit (); }
private:
const ExprT _e;
};
template <typename T, typename ExprT1, typename ExprT2, typename BinOp>
class Expr2Args<T, ExprT1, T, ExprT2, BinOp> {
typedef typename BinOpTraits<Bin Op>::limit_op limit_op;
public:
typedef T return_type;
Expr2Args(const ExprT1 e1, const ExprT2 e2) : _e1(e1), _e2(e2) {}
return_type operator()(int i1, int i2) const { return
BinOp()(_e1(i1, i2), _e2(i1, i2)); }
int the_1st_min_lim it() const { return
limit_op::min_l imit(_e1.the_1s t_min_limit(), _e2.the_1st_min _limit());
}
int the_1st_max_lim it() const { return
limit_op::max_l imit(_e1.the_1s t_max_limit(), _e2.the_1st_max _limit());
}
int the_2nd_min_lim it() const { return
limit_op::min_l imit(_e1.the_2n d_min_limit(), _e2.the_2nd_min _limit());
}
int the_2nd_max_lim it() const { return
limit_op::max_l imit(_e1.the_2n d_max_limit(), _e2.the_2nd_max _limit());
}
private:
const ExprT1 _e1;
const ExprT2 _e2;
};
template <typename ExprT>
Expr2Args<typen ame ExprT::return_t ype, ExprT, void, void, void>
cast1stArg(cons t ExprT e) {
return Expr2Args<typen ame ExprT::return_t ype, ExprT, void, void,
void>(e);
}
template <typename ExprT>
Expr2Args<void, void, typename ExprT::return_t ype, ExprT, void>
cast2ndArg(cons t ExprT e) {
return Expr2Args<void, void, typename ExprT::return_t ype, ExprT,
void>(e);
}
template <typename T11, typename ExprT11, typename T12, typename
ExprT12, typename BinOp1, typename T21, typename ExprT21, typename T22,
typename ExprT22, typename BinOp2>
Expr2Args<typen ame Expr2Args<T11, ExprT11, T12, ExprT12,
BinOp1>::return _type, Expr2Args<T11, ExprT11, T12, ExprT12, BinOp1>,
typename Expr2Args<T21, ExprT21, T22, ExprT22, BinOp2>::return _type,
Expr2Args<T21, ExprT21, T22, ExprT22, BinOp2>, std::plus<typen ame
Expr2Args<T11, ExprT11, T12, ExprT12, BinOp1>::return _type> >
operator+(const Expr2Args<T11, ExprT11, T12, ExprT12, BinOp1>& e1,
const Expr2Args<T21, ExprT21, T22, ExprT22, BinOp2>& e2) {
return Expr2Args<typen ame Expr2Args<T11, ExprT11, T12, ExprT12,
BinOp1>::return _type, Expr2Args<T11, ExprT11, T12, ExprT12, BinOp1>,
typename Expr2Args<T21, ExprT21, T22, ExprT22, BinOp1>::return _type,
Expr2Args<T21, ExprT21, T22, ExprT22, BinOp2>, std::plus<typen ame
Expr2Args<T11, ExprT11, T12, ExprT12, BinOp1>::return _type> >(e1, e2);
}
