template <typename A, typename B>
ResultType<A, B>::Type f(A a, B b)
{
    return a + b;
}

template<typename> struct TypeToSize;
template<> struct TypeToSize<char>              { enum { value = 1 }; };
template<> struct TypeToSize<signed char>       { enum { value = 2 }; };
template<> struct TypeToSize<unsigned char>     { enum { value = 3 }; };
template<> struct TypeToSize<short>             { enum { value = 4 }; };
template<> struct TypeToSize<unsigned short>    { enum { value = 5 }; };
template<> struct TypeToSize<long>              { enum { value = 6 }; };
template<> struct TypeToSize<unsigned long>     { enum { value = 7 }; };
template<> struct TypeToSize<int>               { enum { value = 8 }; };
template<> struct TypeToSize<unsigned int>      { enum { value = 9 }; };
template<> struct TypeToSize<float>             { enum { value = 10 }; };
template<> struct TypeToSize<double>            { enum { value = 11 }; };

template<int> struct SizeToType;
template<> struct SizeToType<1>  { typedef char           Type; };
template<> struct SizeToType<2>  { typedef signed char    Type; };
template<> struct SizeToType<3>  { typedef unsigned char  Type; };
template<> struct SizeToType<4>  { typedef short          Type; };
template<> struct SizeToType<5>  { typedef unsigned short Type; };
template<> struct SizeToType<6>  { typedef long           Type; };
template<> struct SizeToType<7>  { typedef unsigned long  Type; };
template<> struct SizeToType<8>  { typedef int            Type; };
template<> struct SizeToType<9>  { typedef unsigned int   Type; };
template<> struct SizeToType<10> { typedef float          Type; };
template<> struct SizeToType<11> { typedef double         Type; };

template<typename A, typename B>
struct ResultType
{
  template<typename T>
  static char (&deduce(const T&))[TypeToSize<T>::value]; 
  
  typedef typename SizeToType<sizeof(deduce(A() * B()))>::Type Type;
};

template <typename A, typename B>
typename ResultType<A, B>::Type sum(A a, B b)
{
  return a + b;
}

int main()
{
  std::cout << sum(0.5, 42) << std::endl;
  std::cout << sum(char(2), unsigned(3)) << std::endl;
}

template<typename A, typename B>
struct ResultType
{
  DECLARE_TYPE_LIST(
    ResultTypes, 
    char, signed char, char,
    short, unsigned short,
    long, unsigned long,
    int, unsigned int,
    float, double);

  template<typename T>
  static char (&deduce(const T&))[ResultTypes::TypeIndex<T>::value + 1]; 
  
  enum { type_index = sizeof(deduce(A() * B())) - 1 };
  
  typedef typename ResultTypes::TypeByIndex<type_index>::Type Type;
};

//наш волшебный числовой тип
typedef boost::variant<
    unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long,
    signed char, signed short, signed int, signed long, signed long long,
    float, double, long double> number;

struct addition
{//Добавлялка. Отнималка, умножалка и делилка делаются аналогичною
    typedef number result_type;
    
    template<class A1, class A2> 
    result_type operator()(A1 const& a1, A2 const& a2) const 
    { 
        return result_type(a1 + a2); 
    }
};

int main()
{
    number n;
    
    n = boost::apply_visitor(addition(), number('\1'), number(5));
    std::cout << n.which() << ':' << n << std::endl;
    
    n = boost::apply_visitor(addition(), number('\1'), number(.5));
    std::cout << n.which() << ':' << n << std::endl;
    
    n = boost::apply_visitor(addition(), number('\1'), number(.5f));
    std::cout << n.which() << ':' << n << std::endl;

    n = boost::apply_visitor(addition(), number('\1'), number((long double).5));
    std::cout << n.which() << ':' << n << std::endl;

    n = boost::apply_visitor(addition(), number(1UL), number(2U));
    std::cout << n.which() << ':' << n << std::endl;
}

А>template <typename A, typename B>
А>ResultType<A, B>::Type f(A a, B b)
А>{
А>    return a + b;
А>}
А>

template <typename A, typename B>
auto f(A a, B b) -> decltype(a + b)
{
    return a + b;
}