template<typename T1, typename T2 , typename T3> Res f(T1 a, T2 b, T3 c);

template<typename T1, typename T2, typename Enabler = void> struct ResultTypeSelector {typedef T type;};

template<typename T1, typename T2>
struct ResultTypeSelector <T, typename std::enable_if_t<

(std::is_intergal<T1>::value) && (std::is_intergal<T2>::value) &&
(std::numeric_limits<T1>::digits <= 32) &&
(std::numeric_limits<T2>::digits <= 32) 

>
{
//тут описываешь свои правила
    typedef int32_t ResType; //тип результата
    typedef int32_t IntermedType; //тип промежуточных данных   
};

template<typename T1, typename T2>
struct ResultTypeSelector <T, typename std::enable_if_t<

(std::is_intergal<T1>::value) && (std::is_intergal<T2>::value) &&
((std::numeric_limits<T1>::digits > 32) ||
(std::numeric_limits<T2>::digits  > 32)) 

>
{
//тут описываешь свои правила
    typedef int64_t ResType; //тип результата
    typedef int64_t IntermedType; //тип промежуточных данных   
};

An explicit instantiation of a class, function template, or variable template specialization is placed in the namespace in which the template is defined. An explicit instantiation for a member of a class template is placed in the namespace where the enclosing class template is defined. An explicit instantiation for a member template is placed in the namespace where the enclosing class or class template is defined.

ЕМ>  template <typename ArgType, typename ResType>
ЕМ>  ResType func (ArgType Arg) { return ResType (Arg * i);   }
ЕМ>

class Calc { … };

template short Calc::func <short, short> (short z);

template short A::func (short);
template short A::func<> (short);
template short A::func<short> (short);
template short A::func<short, short> (short);

ЕМ>template <typename ResType, typename ArgType> ResType MulDiv (ArgType a, ArgType b) {
ЕМ>  return static_cast <ResType> (a * b / 1000000);
ЕМ>}

ЕМ>  return static_cast <ResType> (static_cast <ResType> (0) + a * b / 1000000);

ЕМ>Я бы с удовольствием, но у меня много кода под виндовое ядро, там std [почти] нет, а выдирать и тащить фрагментами — то еще удовольствие. Ну и очень желательно сделать все средствами VC++ 15.00 (из VS 2008 и WDK 7).

template<typename First, typename Second> is_same{static const bool value = false;};
temaple<typename T> is_same<T, T>{static const bool value = true;}


template<bool Key, class T = void> struct enable_if{};
template<class T> struct enable_if<true, T> {typedef T type;};

  template <typename ArgType, typename ResType>
  ResType func (ArgType Arg) { return ResType (Arg * i);   }

  template short func <short, short> (short);

class Calc {

  int i;

  public:

  template <typename ArgType, typename ResType>
  ResType func (ArgType Arg) { return ResType (Arg * i);   }

  template <> short func <short, short> (short);
  template <> unsigned int func <unsigned int, unsigned int> (unsigned int);

};



int f (short s, unsigned int ui) {

  Calc c;

  short s2 = c.func <short, short> (s);

  unsigned int ui2 = c.func <unsigned int, unsigned int> (ui);

  return int (s2 + ui2);

}


int main () {

  return f (-31435, 8757849873);

}

template <typename ResType, typename ArgType> ResType MulDiv (ArgType a, ArgType b) {
  return static_cast <ResType> (a * b / 1000000);
}

  return static_cast <ResType> (static_cast <ResType> (0) + a * b / 1000000);

ЕМ>  return static_cast <ResType> (static_cast <ResType> (0) + a * b / 1000000);
ЕМ>

template<typename T, typename Enabler = void> struct ResultTypeSelector {typedef T type;};

template<typename T>
struct ResultTypeSelector <T, typename std::enable_if_t<std::is_same<T,int>::value>>
{
//тут описываешь свои правила
    typedef int64_t type;
    typedef int64_t IntermedType;    
};

//и т.п. 


template <typename ArgType> typename ResultTypeSelector<ArgType>::type MulDiv (ArgType a, ArgType b) {
    using ReturnType = ResultTypeSelector<ArgType>::type;
    using IntermedType = ResultTypeSelector<ArgType>::IntermedType;
    return ReturnType((IntermedType(a) * IntermedType(b)/10000));
}

ЕМ>template <typename ResType, typename ArgType> ResType MulDiv (ArgType a, ArgType b) {
ЕМ>  return static_cast <ResType> (a * b / 1000000);
ЕМ>}
ЕМ>

template <typename T, typename U>
using ProductType = decltype(std::declval<T>() * std::declval<U>());

template <typename T, typename U>
ProductType<T, U> MulDiv(const T& t, const U& u) { return t * u / 1000000; }

ЕМ>Вот меня и вымораживает то, что вместо адекватных языковых средств управления приоритетами и доступностью шаблонных функций, идеологами C++ предлагаются извращения через метапрограммирование. По сути, это костыли, и выглядят уродливо, хотя и работают как-то. Очень трудно заставить себя это использовать. Спасибо за идею — буду пробовать, если не запинаю более традиционными способами.

template<typename T> T MulAddDiv( T a, T b, T c, T d)
{
    return (a * b + c) / d;
}

template<typename TRes> TRes MulAddDiv( int a, int b, int c, int d)
{
    return static_cast<TRes>( тут вычисляем  с использованием особенностей x86 )
}