Существует отличная статья на С++ для научных вычислений, где автор (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 году, и мы знаем, что С++ значительно изменилась за последнее десятилетие. Поэтому мой вопрос следующий:
Есть ли современный, идиоматический подход С++ 11 к решению проблемы продвижения по типу, столь же эффективный, как подход, основанный на характеристиках, введенный Veldhuizen?
Изменить (при использовании std::common_type)
Основываясь на предположении Люка Дантона, я создал следующий код, который использует 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>!?
