Идиоматическое продвижение типа C ++ 11

Есть отличная газета на C ++ для научных вычислений, где автор (T. Veldhuizen) предлагает черты на основе подход к продвижению типа адреса. Я использовал такой подход и нашел его эффективным:

#include<iostream>
#include<complex>
#include<typeinfo>

template<typename T1, typename T2>
struct promote_trait{};

#define DECLARE_PROMOTION(A, B, C) template<> struct promote_trait<A, B> { using T_promote = C;};

DECLARE_PROMOTION(int, char, int);
DECLARE_PROMOTION(int, float, float);
DECLARE_PROMOTION(float, std::complex<float>, std::complex<float>);

// similarly for all possible type combinations...

template<typename T1, typename T2>
void product(T1 a, T2 b) {
using T = typename promote_trait<T1, T2>::T_promote;
T ans = T(a) * T(b);
std::cout<<"received "<<typeid(T1).name()<<"("<<a<<")"<<" * "<<typeid(T2).name()<<"("<<b<<")"<<" ==> "<<"returning "<<typeid(T).name()<<"("<<ans<<")"<<std::endl;
}

int main() {
product(1, 'a');
product(1, 2.0f);
product(1.0f, std::complex<float>(1.0f, 2.0f));
return 0;
}

Выход:

received i(1) * c(a) ==> returning i(97)
received i(1) * f(2) ==> returning f(2)
received f(1) * St7complexIfE((1,2)) ==> returning St7complexIfE((1,2))

имя типов, возвращаемых typeinfo, зависит от реализации; ваш вывод может отличаться от моего, который использовал GCC 4.7.2 на OS X 10.7.4

По сути, подход определяет promote_trait который содержит просто одно определение типа: тип, к которому должны быть отнесены два типа при работе определенным образом. Нужно объявить все возможные акции.

Когда одна функция получает оба типа, она полагается на promote_trait вывести правильный, продвигаемый тип результата. Если черта не была определена для данной пары, код не компилируется (желательная особенность).

Теперь эта статья была написана в 2000 году, и мы знаем, что C ++ значительно эволюционировал за последнее десятилетие. Мой вопрос заключается в следующем:

Существует ли современный идиоматический подход C ++ 11 к продвижению типов, столь же эффективный, как подход, основанный на особенностях, введенный Вельдхуйзеном?

Основываясь на предложении Люка Дантона, я создал следующий код, который использует std::common_type:

#include<iostream>
#include<complex>
#include<typeinfo>
#include<typeindex>
#include<string>
#include<utility>
#include<map>

// a map to homogenize the type names across platforms
std::map<std::type_index, std::string> type_names = {
{typeid(char)                 , "char"},
{typeid(int)                  , "int"},
{typeid(float)                , "float"},
{typeid(double)               , "double"},
{typeid(std::complex<int>)    , "complex<int>"},
{typeid(std::complex<float>)  , "complex<float>"},
{typeid(std::complex<double>) , "complex<double>"},
};

template<typename T1, typename T2>
void promotion(T1 a, T2 b) {
std::string T1name = type_names[typeid(T1)];
std::string T2name = type_names[typeid(T2)];
std::string TPname = type_names[typeid(typename std::common_type<T1, T2>::type)];
std::cout<<T1name<<"("<<a<<") and "<<T2name<<"("<<b<<") promoted to "<<TPname<<std::endl;
}

int main() {
promotion(1, 'a');
promotion(1, 1.0);
promotion(1.0, 1);
promotion(std::complex<double>(1), 1);
promotion(1.0f, 1);
promotion(1.0f, 1.0);
promotion(std::complex<int>(1), std::complex<double>(1));
promotion(std::complex<double>(1), std::complex<int>(1));
promotion(std::complex<float>(0, 2.0f), std::complex<int>(1));

return 0;
}

с выходом:

int(1) and char(a) promoted to int
int(1) and double(1) promoted to double
double(1) and int(1) promoted to double
complex<double>((1,0)) and int(1) promoted to complex<double>
float(1) and int(1) promoted to float
float(1) and double(1) promoted to double
complex<int>((1,0)) and complex<double>((1,0)) promoted to complex<int>
complex<double>((1,0)) and complex<int>((1,0)) promoted to complex<int>
complex<float>((0,2)) and complex<int>((1,0)) promoted to complex<int>

Я с удивлением заметил, что все, кроме трех последних рекламных акций, — это то, что я ожидал. Почему бы complex<int> а также complex<double> или же complex<float> быть повышен до complex<int>!?