#include <cassert>
#include <iostream>

struct default_type {
  template<typename T>
  operator T() {}
};

struct A {} ;
struct B : A {};
struct C {};

template<typename T>
struct class_tag{};

template<typename T>
class_tag<T>
class_of(T) { return class_tag<T>();};

// class_of wrapper not to evalute 'x'
#define CLASS_OF(x) (true? default_type() : class_of(x) )

#define CHOSE2(a, b) (true? a() : b() )
#define CHOSE3(a, b, c) (true? a() : true? b() : c() )
#define CHOSE4(a, b, c, d) (true? a() : true? b() : true? c() : d() )

template<typename T>
void print(class_tag<T>) {
  std::cout << typeid(T).name() << std::endl;
}

template<int> 
struct int_to_type;

template<>
struct int_to_type<1> { typedef A type; };
template<>
struct int_to_type<2> { typedef B type; };
template<>
struct int_to_type<3> { typedef C type; };

template<int I>
struct result {
  typedef char type_x[I];
  typedef type_x & type;
};

result<1>::type select(A);
result<2>::type select(B);
result<3>::type select(C);

template<typename T, typename J> struct is_same { enum { value = 0}; };
template<typename T> struct is_same<T, T> { enum { value = 1  }; };

int main() {
  print(CLASS_OF(CHOSE2(A, A)));
  print(CLASS_OF(CHOSE2(A, B)));
  print(CLASS_OF(CHOSE2(B, B)));
  print(CLASS_OF(CHOSE2(B, default_type)));
  print(CLASS_OF(CHOSE2(A, default_type)));
  print(CLASS_OF(CHOSE3(A, A, default_type)));
  print(CLASS_OF(CHOSE3(A, B, default_type)));
  print(CLASS_OF(CHOSE3(A, default_type, default_type)));
  //print(CLASS_OF(CHOSE2(A, C))); // fail


  assert((is_same<A, int_to_type<sizeof(select(CHOSE2(A, A)))>::type>::value));
  assert((is_same<A, int_to_type<sizeof(select(CHOSE2(A, B)))>::type>::value));
  assert((is_same<A, int_to_type<sizeof(select(CHOSE2(A, B)))>::type>::value));
  assert((is_same<B, int_to_type<sizeof(select(CHOSE2(B, B)))>::type>::value));
  assert((is_same<A, int_to_type<sizeof(select(CHOSE2(A, default_type)))>::type>::value));
}