In C++ programming, it is common to check if a particular type exists or to perform type traits operations based on the presence or absence of certain types. One of the challenges faced when dealing with type traits is that if the type being checked does not exist, it can result in compiler errors and make the code more difficult to debug.

Fortunately, C++17 introduced a new helper mechanism called std::void_t that makes it easier to handle nonexistent types in type traits. This feature allows us to check if a type exists and perform certain operations depending on the outcome.

What is std::void_t?

std::void_t is a template metafunction that takes any number of template arguments but discards them. It always evaluates to void. By using std::void_t, we can create a type trait that conditionally selects a type based on its existence.

Using std::void_t to handle nonexistent types

Let’s see an example where std::void_t can be used effectively. Imagine we have a type trait has_member_function_foo that checks if a class has a member function named foo:

template<typename, typename = std::void_t<>>
struct has_member_function_foo : std::false_type {};

template<typename T>
struct has_member_function_foo<T, std::void_t<decltype(std::declval<T>().foo())>> : std::true_type {};

In the above code snippet, we define a primary template for has_member_function_foo where the default template argument is std::void_t. This defaults the trait to false. However, if the expression std::declval<T>().foo() is well-formed, the specialization for has_member_function_foo with std::void_t of the member function type is selected, making the trait true.

Now, using has_member_function_foo, we can conditionally enable certain functionality for types that have the member function foo:

template<typename T>
void do_something(T& obj)
{
    if constexpr(has_member_function_foo<T>::value)
    {
        obj.foo();
    }
    else
    {
        // Handle types without foo()
    }
}

In the above example, if T has a member function foo, it will be invoked. Otherwise, a fallback behavior can be implemented.

Benefits of using std::void_t

By using std::void_t, we can write more concise and versatile type traits that handle the presence or absence of types more elegantly. It eliminates the need for cumbersome workaround techniques, like using decltype and SFINAE (Substitution Failure Is Not An Error), for checking type existence.

Conclusion

std::void_t is a powerful tool in C++ for handling nonexistent types in type traits. It simplifies the code and eliminates the need for complex workarounds. By leveraging std::void_t, we can write cleaner and more robust code that handles type traits gracefully, even in the presence of nonexistent types.

#cplusplus #typetraits