On Fri, Dec 16, 2011 at 2:46 PM, Rhys Ulerich <rhys.ulerich@gmail.com>wrote:

'Afternoon,

I have a quick question on call traits and template argument deduction. I want to use call_traits' value_type and param_type to deduce a signature like double desired_result(double const& x); given an argument of type double.

Is there any way to get type deduction working on a snippet like lousy_attempt (below) to produce my desired_result?

#include <boost/call_traits.hpp>

template<typename Scalar> typename boost::call_traits<Scalar>::value_type lousy_attempt(typename boost::call_traits<Scalar>::param_type x) { return x; }

int main() { double y = 5;

// Works... lousy_attempt<double>(y);

// "No matching function call to lousy_attempt(double&)" lousy_attempt(y);

return 0; }

Thanks in advance, Rhys

What you're doing can't work, as the compiler cannot deduce a template parameter based on matching to a nested type. Consider an arbitrary metafunction X<T>, with any number of specializations; how could the compiler deduce the correct "T" to match double (or whatever type) to X<T>::type? The compiler has no way of going from the ::type you're trying to match back to T. If you really want this effect, you can use Boost.EnableIf: template< class T > typename boost::enable_if_c< boost::is_same< T const, typename boost::call_traits<T>::param_type >::value

::type f(T const x) { /*...*/ }

template< class T > typename boost::enable_if_c< boost::is_same< T const &, typename boost::call_traits<T>::param_type >::value

::type f(T const & x) { /*...*/ }

Or, you can explicitly provide the template parameter to your definition of lousy_attempt. Or pass an extra, dummy argument to your function that presents T in a deduced context. But I would generally recommend to just use T const &. - Jeff