Modern C++: Harnessing Concepts and Modules for Cleaner Code

Concepts, introduced in C++20, are compile‑time predicates that constrain template parameters. They let you specify exactly what a type must support, turning cryptic substitution failures into readable error messages. For instance, the std::integral concept ensures a type is an integral numeric type, eliminating the need for static_assert and enable_if gymnastics.

A typical use case is a generic algorithm that should only work with sortable containers:

#include <concepts>
#include <iterator>
#include <algorithm>

template <std::ranges::input_range R>
requires std::sortable<std::ranges::iterator_t<R>>
void quick_sort(R&& r) {
    auto first = std::begin(r);
    auto last  = std::end(r);
    std::sort(first, last);
}

Here, std::sortable is a concept defined by the Standard Library that checks if a range’s iterator satisfies the requirements for sorting. If you try to instantiate quick_sort with a range of std::string objects, the compiler will produce a clear message that the range is not sortable, rather than a maze of deduction failures.

Modules, also standardized in C++20, address the long‑standing “include hell.” A module interface file declares and exports symbols, while module implementation files provide definitions. The main advantage is that the compiler can skip re‑parsing the same headers, drastically reducing compilation times:

// math.modul
export module math;          // module interface partition
export int add(int a, int b);
export double square(double x);

int add(int a, int b) { return a + b; }
double square(double x) { return x * x; }

In a consumer translation unit:

import math;                 // no need for #include <math.h>
int main() {
    int sum = add(3, 4);
    double sq = square(2.5);
}

Because the compiler knows the exact interface of math, it can compile main.cpp without scanning the module’s source, leading to faster incremental builds.

Combining Concepts and Modules yields powerful, expressive code. For example, you can export a concept from a module:

// containers.modul
export module containers;
export template<typename T>
concept Iterable = requires(T t) {
    { std::begin(t) } -> std::input_iterator;
    { std::end(t) } -> std::input_iterator;
};

Now any module importing containers can constrain templates to only accept iterable types, ensuring compile‑time safety across your entire codebase.

When adopting these features, remember:

• Use concepts to document intent and catch errors early.
• Organize related declarations in modules to improve compile times.
• Pair them with modern tools like Clang-Tidy and CMake’s --parallel flag to fully exploit their benefits.

With Concepts clarifying template contracts and Modules simplifying dependencies, modern C++ developers can write code that is both safer and faster to compile, bringing us closer to the ideal of expressive yet efficient software.