Using static_assert in Template Code
The lesson shows an example of using static_assert() with std::is_floating_point to validate template parameters. What are some other common type traits I can use for template validation?
static_assert() is extremely useful in template code for validating template parameters at compile-time. It allows you to provide clearer error messages and avoid instantiating invalid template specializations.
Here are some common type traits from the <type_traits> header that are useful for template validation:
Example 1: std::is_integral and std::is_floating_point:
template <typename T>
T sum(T a, T b) {
static_assert(std::is_integral<T>::value ||
std::is_floating_point<T>::value,
"sum() requires numeric types");
return a + b;
}Example 2: std::is_base_of:
template <typename T>
class Derived : public T {
static_assert(std::is_base_of<Base, T>::value,
"T must be derived from Base");
// ...
};Example 3: std::is_same:
template <typename T, typename U>
void assert_same() {
static_assert(std::is_same<T, U>::value,
"Types must be the same");
}Example 4: std::is_pointer and std::is_reference:
template <typename T>
void process(T t) {
static_assert(!std::is_pointer<T>::value,
"Pointers are not allowed");
static_assert(!std::is_reference<T>::value,
"References are not allowed");
// ...
}Example 5: std::is_constructible:
template <typename T, typename... Args>
void construct(Args&&... args) {
static_assert(std::is_constructible<T, Args...>::value,
"T must be constructible from Args");
T obj(std::forward<Args>(args)...);
// ...
}These are just a few examples. The <type_traits> library provides many more type traits for checking properties like const-qualification, volatility, trivial constructibility, default constructibility, and more.
In C++17 and later, you can use the _v suffixed versions of the type traits for a more concise syntax:
template <typename T>
void foo(T t) {
static_assert(std::is_integral_v<T>,
"foo() requires an integral type");
// ...
}Using type traits with static_assert in your template code can lead to more expressive and self-documenting interfaces, as well as clearer error messages for users of your templates.
Errors and Assertions
Learn how we can ensure that our application is in a valid state using compile-time and run-time assertions.