C++20 introduced concepts, a language feature that allows programmers to express constraints on template parameters more explicitly and readably. Concepts help you write safer, easier‑to‑understand generic code by filtering template instantiations at compile time. This article delves into the basics of concepts, showcases practical examples, and discusses their impact on template metaprogramming.
1. What Are Concepts?
A concept is a compile‑time predicate that can be applied to a type or set of types. It behaves similarly to a type trait but is more expressive and can combine multiple constraints. Concepts are declared with the concept keyword:
template<typename T>
concept Integral = std::is_integral_v <T>;
template<typename T>
concept Incrementable = requires(T a) {
++a; // pre‑increment
a++; // post‑increment
};
These declarations tell the compiler that a type T satisfies the Integral concept if `std::is_integral_v
` is true, and that it satisfies `Incrementable` if the required operators are available.
—
### 2. Using Concepts in Function Templates
Concepts enable *constrained* function templates. Instead of overloading or using SFINAE tricks, you can state the requirement directly:
“`cpp
template
T add(T a, T b) {
return a + b;
}
“`
When `add` is instantiated with a non‑integral type, the compiler emits a clear error message indicating that the type does not satisfy `Integral`.
“`cpp
int main() {
std::cout << add(5, 3); // OK
// std::cout << add(5.2, 3.1); // Compilation error: double does not satisfy Integral
}
“`
—
### 3. Combining Concepts
Concepts can be combined using logical operators. This leads to expressive constraints that mirror mathematical logic:
“`cpp
template
concept SignedIntegral = Integral
&& std::is_signed_v;
template
concept FloatingPoint = std::is_floating_point_v
;
template
requires SignedIntegral
|| FloatingPoint
T absolute(T value) {
return value < 0 ? -value : value;
}
“`
The `absolute` function now accepts either signed integral types or any floating‑point type, and the compiler will enforce this rule.
—
### 4. Customizing Standard Algorithms
Consider the standard library's `std::sort`. We can create a custom overload that only participates for containers whose iterator type satisfies `RandomAccessIterator` and whose value type satisfies a user‑defined `Comparable` concept.
“`cpp
template
concept RandomAccessIterator =
std::is_base_of_v<std::random_access_iterator_tag, typename std::iterator_traits::iterator_category>;
template
concept Comparable = requires(T a, T b) {
{ a
std::convertible_to;
};
template
void quick_sort(Iter begin, Iter end) {
// Implementation omitted for brevity
}
“`
Now, calling `quick_sort` with a list iterator will fail to compile because `std::list` iterators are not random access, providing an immediate and meaningful feedback.
—
### 5. Performance and Compile‑Time Guarantees
Because concepts perform checks at compile time, they eliminate a large class of runtime errors. For example, a generic matrix library can enforce that the element type supports arithmetic before performing any operations, preventing subtle bugs in user code.
Additionally, constraints can sometimes lead to better code generation. The compiler knows exactly which overloads are viable and can optimize away generic dispatch mechanisms, resulting in more efficient machine code.
—
### 6. Practical Tips
| Tip | Why It Helps |
|—–|————–|
| **Name concepts clearly** (e.g., `Iterable`, `Sortable`) | Improves readability |
| **Use `requires` clauses for non‑template functions** | Keeps signatures clean |
| **Prefer concepts over SFINAE where possible** | Safer, clearer errors |
| **Document concepts** | Others can reuse your constraints |
—
### 7. A Full Example
Below is a small but complete program that demonstrates concepts in action:
“`cpp
#include
#include
#include
#include
#include
// Concept definitions
template
concept Integral = std::is_integral_v
;
template
concept FloatingPoint = std::is_floating_point_v
;
template
concept Number = Integral
|| FloatingPoint;
// Generic sum
template
T sum(const std::vector
& data) {
T total{};
for (const auto& v : data) total += v;
return total;
}
// Generic max
template
T max(const std::vector
& data) {
return *std::max_element(data.begin(), data.end());
}
int main() {
std::vector
vi{1, 2, 3, 4};
std::vector
vd{1.5, 2.5, 3.5};
std::cout << "Sum of ints: " << sum(vi) << '\n';
std::cout << "Max of ints: " << max(vi) << '\n';
std::cout << "Sum of doubles: " << sum(vd) << '\n';
std::cout << "Max of doubles: " << max(vd) << '\n';
// std::vector vs{“a”, “b”}; // Would fail to compile: std::string not Number
}
“`
Compile with a C++20‑compatible compiler (`-std=c++20` for GCC/Clang). The commented line demonstrates the compile‑time safety: attempting to use `sum` with `std::string` would trigger a constraint violation error.
—
### 8. Conclusion
C++20 concepts bring a powerful, declarative way to express template requirements. They improve code safety, clarity, and maintainability, and they integrate seamlessly with the rest of the C++ type system. Embracing concepts early in your projects will set a solid foundation for writing robust generic code.
