Использование заголовка продвижения арифметики C++

Для этого можно использовать оператор ?:. Он даст вам общий тип между двумя типами. Во-первых, если два типа одинаковы, то все в порядке. Затем, если типы различаются, вы вызываете ?: и смотрите, какой тип вы получите обратно.

Вам нужно иметь особый случай для непродвинутых типов char, short и их беззнаковых/знаковых версий, поскольку при применении к двум таким операндам разных типов, результатом не будет ни один из них. Также необходимо позаботиться о случае, когда два класса могут быть преобразованы в раскрученные арифметические типы. Чтобы разобраться с этим, мы проверяем, является ли результат ?: раскрученным арифметическим типом (в духе пункта 13.6), и используем этот тип.

// typedef eiher to A or B, depending on what integer is passed
template<int, typename A, typename B>
struct cond;

#define CCASE(N, typed) \
  template<typename A, typename B> \
  struct cond<N, A, B> { \
    typedef typed type; \
  }

CCASE(1, A); CCASE(2, B);
CCASE(3, int); CCASE(4, unsigned int);
CCASE(5, long); CCASE(6, unsigned long);
CCASE(7, float); CCASE(8, double);
CCASE(9, long double);

#undef CCASE

// for a better syntax...
template<typename T> struct identity { typedef T type; };

// different type => figure out common type
template<typename A, typename B>
struct promote {
private:
  static A a;
  static B b;

  // in case A or B is a promoted arithmetic type, the template
  // will make it less preferred than the nontemplates below
  template<typename T>
  static identity<char[1]>::type &check(A, T);
  template<typename T>
  static identity<char[2]>::type &check(B, T);

  // "promoted arithmetic types"
  static identity<char[3]>::type &check(int, int);
  static identity<char[4]>::type &check(unsigned int, int);
  static identity<char[5]>::type &check(long, int);
  static identity<char[6]>::type &check(unsigned long, int);
  static identity<char[7]>::type &check(float, int);
  static identity<char[8]>::type &check(double, int);
  static identity<char[9]>::type &check(long double, int);

public:
  typedef typename cond<sizeof check(0 ? a : b, 0), A, B>::type
    type;
};

// same type => finished
template<typename A>
struct promote<A, A> {
  typedef A type;
};

Если ваши типы Complex могут быть преобразованы друг в друга, то ?: не найдет общего типа. Вы можете специализировать promote, чтобы указать ему, как найти общий тип двух Complex:

template<typename T, typename U>
struct promote<Complex<T>, Complex<U>> {
  typedef Complex<typename promote<T, U>::type> type;
};

Использование простое:

int main() {
  promote<char, short>::type a;
  int *p0 = &a;

  promote<float, double>::type b;
  double *p1 = &b;

  promote<char*, string>::type c;
  string *p2 = &c;
}

Обратите внимание, что для реального использования лучше всего уловить несколько случаев, которые я опустил для простоты, например, следует обрабатывать аналогично (лучше всего сначала снять const и volatile и преобразовать T[N] в T* и T& в T, а затем делегировать к настоящему шаблону promote - i. т.е. сделать boost::remove_cv>::type для обоих A и B перед их делегированием). Если этого не сделать, то вызов check закончится неоднозначностью для таких случаев.