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.