Constraining Template Arguments

Constraining template arguments is a powerful feature in C++ that allows you to restrict which types can be used with your templates. This can help prevent errors, improve compile-time error messages, and make your code more self-documenting.

There are several ways to achieve this, with the most modern and recommended approach being concepts, introduced in C++20.

Here are the main approaches, starting with the most modern:

1. Concepts (C++20 and later)

Concepts provide a way to specify constraints on template arguments directly in the template declaration.

1#include <concepts>
2#include <iostream>
3
4// Define a concept
5template <typename T>
6concept Numeric = std::integral<T>
7  || std::floating_point<T>;
8
9// Use the concept in a template
10template <Numeric T>
11T Add(T a, T b) {
12  return a + b;
13}
14
15int main() {
16  // Works with int
17  std::cout << Add(5, 3) << '\n';
18
19  // Works with double
20  std::cout << Add(3.14, 2.86) << '\n';
21  
22  // This would not compile
23  Add("Hello", "World");
24}

1error: 'Add': no matching overloaded function found
2note: could be 'T Add(T,T)'
3note: the associated constraints are not satisfied

2. SFINAE (Substitution Failure Is Not An Error)

For pre-C++20 code, SFINAE is a common technique to constrain templates.

1#include <iostream>
2#include <type_traits>
3
4template <
5  typename T,
6  typename = std::enable_if_t<std::is_arithmetic_v<T>>
7>
8T Add(T a, T b) {
9  return a + b;
10}
11
12int main() {
13  // Works with int
14  std::cout << Add(5, 3) << '\n';
15
16  // Works with double
17  std::cout << Add(3.14, 2.86) << '\n';
18  
19  // This would not compile
20  Add("Hello", "World");
21}

1error: 'Add': no matching overloaded function found
2note: could be 'T Add(T,T)'
3note: 'T Add(T,T)': could not deduce template argument for '<unnamed-symbol>'

3. Static Assertions

While not as flexible as the above methods, static assertions can be used to provide clear error messages when constraints are violated.

1#include <iostream>
2#include <type_traits>
3
4template <typename T>
5T Add(T a, T b) {
6  static_assert(
7    std::is_arithmetic_v<T>,
8    "Add only works with numeric types"
9  );
10  return a + b;
11}
12
13int main() {
14  // Works with int
15  std::cout << Add(5, 3) << '\n';
16
17  // Works with double
18  std::cout << Add(3.14, 2.86) << '\n';
19
20  // This would cause a static assertion failure
21  Add("Hello", "World");
22}

1error: static_assert failed: 'Add only works with numeric types'

4. Tag Dispatching

This technique uses function overloading and tag types to select different implementations based on type properties.

1#include <iostream>
2#include <type_traits>
3
4// Implementation for arithmetic types
5template <typename T>
6T Add(T a, T b, std::true_type) {
7  return a + b;
8}
9
10// Implementation for non-arithmetic types
11// (will cause a compile error)
12template <typename T>
13T Add(T a, T b, std::false_type) {
14  static_assert(
15    std::is_arithmetic_v<T>,
16    "Add only works with numeric types"
17  );
18
19  // Never reached due to the static_assert
20  return T{};
21}
22
23// Public interface
24template <typename T>
25T Add(T a, T b) {
26  return Add(a, b, std::is_arithmetic<T>{});
27}
28
29int main() {
30  // Works with int
31  std::cout << Add(5, 3) << '\n';
32
33  // Works with double
34  std::cout << Add(3.14, 2.86) << '\n';
35
36  // This would cause a compile error
37  Add("Hello", "World");
38}

1error: static_assert failed: 'Add only works with numeric types'

Each of these approaches has its strengths:

• Concepts provide the clearest syntax and best error messages.
• SFINAE is widely supported and can be very flexible.
• Static assertions provide very clear error messages but are less flexible.
• Tag dispatching can be used to select entirely different implementations based on type properties.

When constraining template arguments, choose the approach that best fits your needs and the C++ version you're targeting. In modern C++, concepts are generally the preferred approach when available.