Nathan Ridge wrote:

...

You're not doing wrong. This is caused by incorrect use of `result_of`.

Changing the line 56 of boost/ptr_container/indirect_fun.hpp BOOST_DEDUCED_TYPENAME result_of< Fun( BOOST_DEDUCED_TYPENAME pointee::type& ) >::type to BOOST_DEDUCED_TYPENAME result_of< const Fun( BOOST_DEDUCED_TYPENAME pointee::type& ) >::type resolves the issue (`Fun` is changed to `const Fun`).

I still get the compiler error after making the change.

Oh sorry, I tested with the trunk version... Regards, Michel

A similar error happens even with tr1 result_of (i.e. without defining BOOST_RESULT_OF_USE_DECLTYPE). Minimal test case (fails to be compiled): #include template <typename T> struct my_less { bool operator()(T const& t1, T const& t2) const { return t1 < t2; } template <typename Sig> struct result; template struct result { typedef bool type; }; }; int main (int argc, char* argv[]) { boost::void_ptr_indirect_fun f; return 0; } The error occurred in the code (at line 105 of ptr_container/indirect_fun.hpp) which determines the return type of unary function call operator of class boost::void_ptr_indirect_fun: result_of::type operator()( const void* r ) const {...} Since result_of only works with two function parameters, this code does not compile. These issues, including OP's one, can be fixed by removing unary function call operator of class boost::void_ptr_indirect_fun (i.e. making it BinaryFunction). Hope this helps, Michel

Thorsten Ottosen wrote:

...

These issues, including OP's one, can be fixed by removing unary function call operator of class boost::void_ptr_indirect_fun (i.e. making it BinaryFunction).

The problem then is that we can't use the class with unary functions. Something that might already we be done by users.

So, how about adding void_ptr_indirect_binary_fun (and void_ptr_indirect_unary_fun)? Then we have void_ptr_indirect_fun (with unary and binary function call operators) void_ptr_indirect_unary_fun (with unary function call operator) void_ptr_indirect_biary_fun (with binary function call operator) and use void_ptr_indirect_binary_fun when wrapping comparators. Regards, Michel

Thorsten Ottosen wrote:

I was messing around with enable_if to see if we could detect the number of arguments. But I couldn't find a traits that does that yesterday ... now I see

could help. This way I think we can avoid instantiating result_of until it works.

Note that you cannot use SFINAE based on template `Fun`'s arity since `Fun` is not a template parameter of void_ptr_indirect_fun's operator(). To avoid unnecessary instanciation of result_of, we might need to make operator() a function template and make its return type a dependent type of its template parameters. The following code works fine: #include #include /* ... */ template struct make_lazy { typedef typename Type::type type; }; template class void_ptr_indirect_fun { /* ... */ template <typename Dummy> typename make_lazy< boost::result_of , Dummy >::type operator()(const Dummy* r) const { BOOST_STATIC_ASSERT(boost::is_void<Dummy>::value); BOOST_ASSERT(r != 0); return fun( *static_cast(static_cast(r)) ); } template <typename Dummy> typename make_lazy< boost::result_of , Dummy >::type operator()(const Dummy* l, const Dummy* r) const { BOOST_STATIC_ASSERT(boost::is_void<Dummy>::value); BOOST_ASSERT(l != 0 && r != 0); return fun( *static_cast(static_cast(l)) , *static_cast(static_cast(r)) ); } /* ... */ }; /* ... */ Regards, Michel

Thorsten Ottosen wrote:

The change is comitted to trunk ... if it goes well, then it can go to release. Check it out if you have the time.

Great! I looked at the code and test it with GCC 4.6. * For indirect_fun, make_lazy is not necessary because the return type of its operator() is already a dependent type. * For indirect_fun, pointee in result_of should not be removed. This broke test/indirect_fun.cpp when compiling with BOOST_RESULT_OF_USE_DECLTYPE. * and should be included even if BOOST_NO_SFINAE is defined. I attached a patch for fixing these problems. After applying this patch, the OP's code, my code with my_less comparator and test/indirect_fun.cpp all run fine (w/wo BOOST_RESULT_OF_USE_DECLTYPE). Thanks, Michel

Den 04-03-2011 08:37, Michel MORIN skrev:

Michel MORIN wrote:

...

I attached a patch for fixing these problems. After applying this patch, the OP's code, my code with my_less comparator and test/indirect_fun.cpp all run fine (w/wo BOOST_RESULT_OF_USE_DECLTYPE).

Ouch! Forgot to attach a patch.

Thanks. Applied to trunk. regards -Thorsten