On Sep 10, 4:36 pm, Joel de Guzman wrote:

On 9/11/10 4:37 AM, alfC wrote:

...

I noticed that in some contexts I have both the object class and the corresponding phoenix function

...

   class impl;    ...

...

   impl f_impl;    boost::phoenix::function<impl>  f(f_impl);

...

now to avoid the copying I could use:

...

   boost::phoenix::function  f(f_impl);

...

which works. Although    boost::phoenix::function  f(f_impl); //doesn't work. (error below)

...

Is there any problem with using references at all, in the first place?

I'm not sure. Could you provide a minimal cpp file I can try?

Yes, see below. Althougth now that I made this example I realize that the underlying object implementation is copied many times anyway (at least 4 times in the example), I guess during the building up of the expression template. [The final objective was to make an object function that not only evaluates but also is able to take expression and build expression templates]. #include #include<iostream> struct F{ double a_; F(double a) : a_(a){std::cout << "F constructed" < pf(f); std::cout << pf(arg1+1.)((double const&)5.) << std::endl; } /* block doesn't work { F f(4.); boost::phoenix::function pf(f); //does not compile std::cout << pf(arg1+1.)((double const&)5.) << std::endl; } */ } prints: F constructed F copied F copied F copied F copied F copied 144 F constructed F copied F copied F copied F copied 144

On Fri, Sep 10, 2010 at 5:47 PM, Joel de Guzman wrote:

On 9/11/10 8:31 AM, alfC wrote:

...

On Sep 10, 4:36 pm, Joel de Guzman  wrote:

...

On 9/11/10 4:37 AM, alfC wrote:

...

I noticed that in some contexts I have both the object class and the corresponding phoenix function

...

   class impl;    ...

...

   impl f_impl;    boost::phoenix::function<impl>    f(f_impl);

...

now to avoid the copying I could use:

...

   boost::phoenix::function    f(f_impl);

...

which works. Although    boost::phoenix::function    f(f_impl); //doesn't work. (error below)

...

Is there any problem with using references at all, in the first place?

I'm not sure. Could you provide a minimal cpp file I can try?

Yes, see below. Althougth now that I made this example I realize that the underlying object implementation is copied many times anyway (at least 4 times in the example), I guess during the building up of the expression template. [The final objective was to make an object function that not only evaluates but also is able to take expression and build expression templates].

Here's my suggestion: write a proxy function object that holds the target function object by reference, pointer, or boost.ref and use that to wrap your phoenix function.

I see, so once phoenix::function takes charge everything is copied by value and I have to provide an extra layer of reference. I think this is a general problem with template code, that wants to assume that the type is a non-reference and suddenly everything is copied by value, although it is clear from the intention that everything should be treated by reference. In fact template code is full of remove_reference and remove_cv, it make the life easier for the template coder but at the cost of certain loss of flexibilty. My point is that most template code should honor const and reference qualifiers and not just get rid of them. (If it can't honor it then the code should not compile). Anyway this is the final code for a funciton object that binds itself upon evaluation on phoenix expression. Although not related to the initial question of the post I would welcome any feedback: (I am not sure if really need the inheritance part) #include #include<iostream> using namespace boost::phoenix; struct F : function{ double a_; F(double a) : function(*this), a_(a){std::cout << "F constructed" <(*this), a_(other.a_){std::cout << "F copied" <, boost::fusion::vector< value<F>, PhoenixExpression > > > operator()(actor<PhoenixExpression> const& a) const{ return function::operator()(a); } }; int main(){ using boost::phoenix::function; using namespace boost::phoenix::arg_names; { F f(4.); std::cout << "normal call " << f(5. + 1.) << std::endl; std::cout << "delayed call " << f(arg1+1.)((double const&)5.) << std::endl; } return 0; } output: F constructed normal call 144 F copied F copied F copied F copied delayed call 144