Re: [Boost-users] Re: Re: Re: Re: result_of tutorial

From: Peter Dimov (pdimov_at_[hidden])
Date: 2005-03-16 13:45:14

Ian McCulloch wrote:
> Peter Dimov wrote:
>
>> No, you don't have to know this in advance. It is up to the
>> implementation or specialization of result_of<F(...)> to handle
>> these cases and return the correct result.
>
> I'm not sure what you mean here.  Do you mean that I should make sure
> that F::result<F(int, int>) and F::result<F(int const&, int)> are
> both defined?

Yes, if you F can be called with an rvalue of type int and with an lvalue of 
type const int.

[...]

> #include <boost/utility/result_of.hpp>
>
> // some example function that passes by const_reference
> template <typename T>
> struct negate
> {
>   typedef T const& argument_type;
>   typedef T result_type;
>
>   result_type operator()(argument_type x) const { return -x; }
> };
>
> // but we don't want to have to specify the parameter types by hand
> struct negate_f
> {
>   template <typename T> struct result {};
>
>   template <typename T>
>   struct result<negate_f(T const&)>  // exact argument_type of
>   negate<T> {
>      typedef typename negate<T>::result_type type;
>   };

This specialization says that negate_f can only accept const lvalues.

>   template <typename T>
>   typename result<negate_f(T const&)>::type
>   operator()(T const& x) const
>   {
>      return negate<T>()(x);
>   }
> };
>
> // generic apply function
> // do we pass by value or const reference here?
> template <typename Func, typename T>
> typename boost::result_of<Func(T)>::type

This says that you ask for type of the return value of F when passed an 
rvalue of type T.

> apply(Func f, T x)
> {
>   return f(x);

But you pass an lvalue of type T here.

> }
>
> int main()
> {
>   apply(negate_f(), 5);
> }

Try this variation instead:

#include <boost/utility/result_of.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>

struct negate;

namespace boost
{

template<class T> struct result_of<negate(T)>
{
    typedef typename remove_reference<T>::type no_ref;
    typedef typename remove_const<no_ref>::type type;
};

} // boost

struct negate
{
   template<class T> T operator()(T const & x) const
   {
      return -x;
   }
};

template <typename Func, typename T>
typename boost::result_of<Func(T&)>::type
apply(Func f, T x)
{
   return f(x);
}

int f( int x )
{
    return -x;
}

int main()
{
   apply( f, 5 );
   apply( negate(), 5 );
}