C++ Concepts

Key Concept Features

template<std::integral T>
void process(T value) { }

// Clear: "T must be integral"
// Instead of template gibberish

concept Printable = requires(T t) {
    std::cout << t;
};

template<Sortable Container>
void sort_data(Container& c);

🔹 Basic Concept Definition

The concept keyword in C++20 enables the definition of named compile‑time predicates for template parameters. Concepts specify requirements that types must satisfy, improving template readability and error messages. For example, a Sortable concept ensures types support comparison and swapping. This enhances code clarity and allows compilers to enforce constraints early, reducing cryptic template errors and facilitating better documentation of generic interfaces.

#include <concepts>

// Simple concept - checks if type has + operator
template<typename T>
concept Addable = requires(T a, T b) {
    a + b;  // Must support addition
};

// Using the concept
template<Addable T>
T sum(T x, T y) {
    return x + y;
}

int main() {
    int result1 = sum(10, 20);        // ✅ Works
    double result2 = sum(1.5, 2.5);   // ✅ Works
    // sum(std::vector{1}, std::vector{2}); // ❌ Error
    return 0;
}

🔹 Standard Library Concepts

C++20’s standard library includes predefined concepts like std::integral and std::floating_point. These built‑in concepts cover common type requirements, reducing boilerplate. For instance, std::integral<int> evaluates to true, enabling templates to restrict parameters to integer families. Utilizing these concepts accelerates development and ensures consistency with the language’s type‑traits system.

#include <concepts>
#include <iostream>

// Using standard concepts
template<std::integral T>
void print_integer(T value) {
    std::cout << "Integer: " << value << std::endl;
}

template<std::floating_point T>
void print_float(T value) {
    std::cout << "Float: " << value << std::endl;
}

int main() {
    print_integer(42);      // ✅ int is integral
    print_float(3.14);      // ✅ double is floating_point
    // print_integer(3.14); // ❌ Error - clear message
    return 0;
}

🔹 Complex Requirements

Concepts can combine multiple requirements using logical operators like && and ||. This allows expressing sophisticated constraints, such as a type being both copyable and comparable. Complex concepts enable precise API specifications, ensuring that templates only accept types meeting all necessary operations, which enhances safety and reduces runtime checks.

#include <concepts>
#include <iostream>

// Complex concept with multiple requirements
template<typename T>
concept Printable = requires(T t) {
    std::cout << t;           // Must be printable
    { t.size() } -> std::integral;  // Must have size() returning integral
};

template<Printable T>
void print_with_size(const T& item) {
    std::cout << "Item: " << item 
              << " (size: " << item.size() << ")" << std::endl;
}

int main() {
    std::string text = "Hello";
    std::vector<int> numbers = {1, 2, 3};
    
    print_with_size(text);     // ✅ Works
    print_with_size(numbers);  // ✅ Works
    // print_with_size(42);    // ❌ Error - no size()
    return 0;
}