Using std::conditional with is_class<int>, getting compile error - c++

Question

I want to have a type which depends on some other class X having X::value_type.
If there is no such typedef inside the other class, I want to just use X by itself.
So I am looking for code like:
TypeChecker<X>::value_type // Here, value_type might be X or X::value_type, depending on X.
But my initial attempts are failing, see below:
Here's a program that does not compile:
#include<type_traits>
template<typename T>
struct TypeChecker {
typedef typename std::conditional<
std::is_class<T>::value,
typename T::value_type, // I believe the error is due to this line (could be wrong)
T>::type value_type;
};
int main()
{
TypeChecker<int>::value_type x = 3;
return 0;
}
It gives: error: 'int' is not a class, struct, or union type
You can try online: godbolt link
I'm confused, because I thought std::conditional would choose the right branch, but it seems to be evaluating both of them, in some sense. At least, enough to cause a compile error.
Help?

Answer 1

The problem is T::value_type is passed to std::conditional as the template argument, when T is int the expression itself is invalid.
You can do it with class template and partial specialization instead.
template<typename T, typename = void>
struct TypeChecker {
typedef T value_type;
};
template<typename T>
struct TypeChecker<T, typename std::enable_if<std::is_class<T>::value>::type> {
typedef typename T::value_type value_type;
};
BTW: std::is_class seems to be much loose condition; you can constrain it as has the member type value_type, e.g.
template<typename T, typename = void>
struct TypeChecker {
typedef T value_type;
};
template<typename T>
struct TypeChecker<T, std::void_t<typename T::value_type>> {
typedef typename T::value_type value_type;
};

Answer 2

std::conditional does not "short-circuit". For std::conditional<C,X,Y> to even be instantiated as a class type, the three template arguments must all be actual types. There's no way to have a template that can be used with one of its template parameters representing an illegal or unknown type, even if that parameter doesn't directly matter.
Some solutions to your TypeChecker:
// C++17, using partial specialization SFINAE:
template <typename T, typename Enable = void>
struct TypeChecker {
using value_type = T;
};
template <typename T>
struct TypeChecker<T, std::void_t<typename T::value_type>> {
using value_type = typename T::value_type;
};
// C++11 or later, using function SFINAE:
template <typename T>
struct type_identity { using type = T; };
template <typename T>
type_identity<typename T::value_type> TypeChecker_helper(int); // not defined
template <typename T>
type_identity<T> TypeChecker_helper(...); // not defined
template <typename T>
struct TypeChecker {
using value_type = typename decltype(TypeChecker_helper<T>(0))::type;
};
(Aside: I'm always a bit suspicious of templates that automatically "unwrap" things, like this TypeChecker. It could thwart code which specifically wants to use a container or iterator as a value directly.)