Re: [Boost-users] Getting the argument types from a function type

From: Benjamin Winkler (Benjamin.Winkler_at_[hidden])
Date: 2007-06-13 17:55:52

Hello Kirit,

to solve your specific problem, you could just do without Boost.function and also use templates for operator():

template <class C, typename F>
class with_binder
{
  C&  m_this;
  F   m_fn;
public:
  with_binder(C& ref, F fn)
    : m_this(ref), m_fn(fn)
  {
  }

  // one parameter
  template <typename T1>
  const with_binder<C,F>& operator()(T1& v1) const
  {
    (m_this.*m_fn)(v1);
    return *this;
  }
  template <typename T1>
  const with_binder<C,F>& operator()(const T1& v1) const
  {
    (m_this.*m_fn)(v1);
    return *this;
  }

  // two parameters
  template <typename T1, typename T2>
  const with_binder<C,F>& operator()(T1& v1, T2& v2) const
  {
    (m_this.*m_fn)(v1, v2);
    return *this;
  }
  template <typename T1, typename T2>
  const with_binder<C,F>& operator()(const T1& v1, const T2& v2) const
  {
    (m_this.*m_fn)(v1, v2);
    return *this;
  }

// ... and so on ...

};

template <class C, typename F>
with_binder<C,F> with(C& ref, F fn)
{
  return with_binder<C,F>(ref,fn);
}

Regards,
Benjamin

>I've been playing around with a few functional programming idioms in C++ 
>using Boost.function and Boost.lambda and was wondering if it was 
>possible to fetch out the argument type (i.e. int) from a type like this:
>
>void (*somefunc)( int )
>
>It looks to me like boost::function<> might be doing something along 
>these lines.
>
>I've been working on a version of 'with' for use in initialising lists 
>etc. At the moment you need to do this:
>
>	std::list< int > list1;
>	list1.push_back( 3 );
>	list1.push_back( 1 );
>	list1.push_back( 4 );
>
>But using 'with' you can do this:
>
>	with( list2, &std::list< int >::push_back )( 3 )( 1 )( 4 )( 1 )( 5 );
>
>The implementation I have right now is fairly simple:
>
>template< typename F >
>struct with_binder {
>	with_binder( F f )
>	: m_f( f ) {
>	}
>	const with_binder &operator()( int i ) const {
>		m_f( i );
>		return *this;
>	}
>private:
>	F m_f;
>};
>template< typename O, typename F > inline
>with_binder< boost::function< void ( int ) > > with( O &o, F f ) {
>	return with_binder< boost::function< void ( int ) > >( 
>boost::lambda::bind( f, &o, boost::lambda::_1 ) );
>}
>
>But the 'int' argument type is hard coded. I could have it as the first 
>template parameter to 'with' and simply require that it is given when 
>using 'with', but it would neater if it could be derived from the type 
>'F' in 'with'. Clearly to be more generally useful it also needs to be 
>extended for multiple parameters.
>
>
>K
>
>_______________________________________________
>Boost-users mailing list
>Boost-users_at_[hidden]
>http://lists.boost.org/mailman/listinfo.cgi/boost-users