Using SFINAE to Check for Member Types

Yes, SFINAE can be used to check for the presence of member types in a similar way to how it's used to check for member functions.

Let's say we want to write a template function foo that only accepts types T that have a member type named value_type. We can achieve this using SFINAE like this:

1#include <iostream>
2#include <type_traits>
3
4template <typename T,
5  typename = std::enable_if_t<
6    std::is_same_v<typename T::value_type, int>>
7>
8void foo(T) {
9  std::cout << "T has a value_type member"
10    " of type int\n";
11}
12
13struct A {
14  using value_type = int;
15};
16
17struct B {
18  using value_type = double;
19};
20
21struct C {
22  // no value_type member
23};
24
25int main() {
26  // OK, A::value_type is int
27  foo(A{});
28
29  // Substitution failure, B::value_type is not int
30  foo(B{});
31
32  // Substitution failure, C has no value_type
33  foo(C{});
34}

Here, the second template parameter of foo is an unused type parameter. The std::enable_if condition checks if T::value_type exists and is the same type as int.

If T has a value_type member type that is int, the condition is true and foo is viable. If T doesn't have a value_type member, or if it has one but it's not int, a substitution failure occurs, removing this foo template from the overload set.

Note that we use typename T::value_type to refer to the member type. The typename keyword is necessary to tell the compiler that value_type is a type, because it's dependent on the template parameter T.

This technique can be used to check for the presence and properties of any member type, not just value_type. It's a powerful tool for template metaprogramming and can be used to implement traits and concepts in pre-C++20 code.