Sorry, I made a couple of mistakes with pointers, here it is again, also simplified: template<class Self> struct lazy{ boost::scoped_ptr<boost::phoenix::function<Self const&> > lazy_; lazy() : lazy_(new boost::phoenix::function<Self const&>(static_cast<Self const&>(*this) ) ){} lazy(lazy const& other) : lazy_(new boost::phoenix::function<Self const&>(static_cast<Self const&>(*this) ) ){} template<class Arg> const boost::phoenix::actor<boost::proto::exprns_::basic_expr<boost::phoenix::detail::tag::function_eval, boost::proto::argsns_::list2<boost::proto::exprns_::basic_expr<boost::proto::tag::terminal, boost::proto::argsns_::term<Self>, 0l>, Arg >, 2l> > operator()(Arg const& arg) const{return (*lazy_)(arg);} }; struct A : lazy<A>{ using lazy<A>::operator(); typedef double result_type; result_type operator()(double const& d) const{return d;} }; On Apr 15, 6:55 pm, alfC <alfredo.cor...@gmail.com> wrote:
Hi,
Is this possible at all?
struct A : boost::phoenix::function<A const&>{ double operator()(double const& d) const{return 5.;}
}
such that an object function it is not only a function but also a lazy function of itself? std::clog << a(4.) << std::endl; std::clog << a(arg1 + 1.)(4.) << std::endl;
the code above doesn't work because A is not complete when the type function<A> is instatiated. However after some experimentation I got the following. The question is, does it really work in more exotic context? Is there a possible simplification? Am I reinventing the wheel?
template<class Self> struct lazy{ boost::phoenix::function<Self const&> const* const lazy_; lazy(Self const& self) : lazy_(new boost::phoenix::function<Self const&>(self)){} template<class Arg> const boost::phoenix::actor<boost::proto::exprns_::basic_expr<boost::phoenix::detail::tag::function_eval, boost::proto::argsns_::list2<boost::proto::exprns_::basic_expr<boost::proto::tag::terminal, boost::proto::argsns_::term<Self>, 0l>, Arg >, 2l> > operator()(Arg const& arg) const{return (*lazy_)(arg);} ~lazy(){delete(lazy_);}
};
struct A : lazy<A>{
using lazy<A>::operator(); A() : lazy<A>(*this){} A(A const& other) : lazy<A>(*this){}
typedef double result_type; result_type operator()(double const& d) const{return d;}
};
so, any function object B can be a lazy function of it self provided that we use the correct CRTP argument (lazy<B>) and manually add the code:
using lazy<A>::operator(); B() : lazy<A>(*this){} B(A const& other) : lazy<A>(*this){}
inside the class. This feature seems to make the usage of the function object b more flexible, since it can we used in many different contexts. For example, as
integrate ( b, 1., 2.);
or as
integrate ( 2.*b(arg1 + 1.) , 1., 2.)
Thanks, Alfredo _______________________________________________ Boost-users mailing list Boost-us...@lists.boost.orghttp://lists.boost.org/mailman/listinfo.cgi/boost-users