What C++20 Modules Will Bring to the C++ Language: Benefits and Detailed Examples

One of the most significant features introduced in C++20 is modules—a modern alternative to the traditional C++ preprocessor-based header/include system. If fully adopted and supported by all compilers in the future, C++20 modules promise to significantly change how C++ programs are structured, compiled, and maintained. In this article, we'll explore what C++20 modules are, their benefits over the traditional header system, and the added value they bring to the language with detailed examples.

What Are C++20 Modules?

C++20 modules are a new language feature designed to replace the preprocessor-based header file inclusion mechanism. Instead of using header files (.h or .hpp) and manually managing #include directives, modules allow code to be compiled and imported in a more structured and efficient way.

The concept behind modules is simple:

• Code is divided into compilation units called modules.

• Modules are imported instead of included, eliminating many issues caused by the old header system (such as macro conflicts, long compile times, and fragile dependencies).

Here’s a simple breakdown:

• Module Interface: The part of the module that exposes functions, classes, and data to other code.

• Module Implementation: The internal workings of the module that are hidden from the user.

Key Benefits of C++20 Modules

1. Improved Compilation Times

One of the biggest complaints about C++ is its slow compile times, largely due to the repetitive inclusion of header files and reprocessing of their contents. With modules, the compiler processes a module only once. Subsequent imports of the module simply reuse the already processed information, leading to significantly faster incremental builds and faster compilation times overall.

Example:

// MathModule.ixx
export module MathModule;

export int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;  // This is internal and not exposed
}

With modules, this MathModule is compiled once, and the add function can be reused in any file that imports this module without needing to recompile the header.

// Main.cpp
import MathModule;

int main() {
    int result = add(5, 3);  // Accessing the exported function
}

Compile time improvements: Instead of processing the entire header for every file that includes it, only the module's precompiled information is loaded.

2. Cleaner Code and Better Encapsulation

The traditional header/include system encourages mixing implementation details with interface declarations, which can lead to header file bloat and leaking internal implementation details. With modules, you can cleanly separate the interface from the implementation, leading to better encapsulation.

In the example above, the add function is exported and visible to other translation units, while the subtract function is internal and hidden from external code. This allows you to control what’s exposed, making the module interface cleaner and less error-prone.

3. Elimination of Header File Problems (Macro Conflicts and Header Guards)

Header files often suffer from issues like macro conflicts and the need for header guards (#ifndef, #define, #endif) to prevent multiple inclusions. Modules solve these problems by not relying on textual inclusion—everything is handled by the compiler directly, so macros and inclusion conflicts are avoided.

Traditional header problems:

// OldMath.h
#define MAX_VALUE 1000

int multiply(int a, int b);

In large projects, this could conflict with another header that defines MAX_VALUE. In contrast, with modules, macros defined in one module do not affect other modules unless explicitly exported.

4. Better Dependency Management

C++ header files can introduce fragile dependencies, where a small change in one header file results in recompiling a large number of source files that include that header. This issue, known as "include hell", is drastically reduced with modules, where changes to internal implementation details do not affect other parts of the program unless explicitly exported.

Modules improve dependency management by allowing more granular control over what is visible to the outside world and what remains hidden. This means fewer unnecessary recompilations, reducing overall development time.

5. Simpler Build Systems

Large C++ projects often have complex build systems due to the management of header file dependencies and recompilation of multiple translation units. By introducing modules, the build process becomes more streamlined, as the compiler can directly track module dependencies. This reduces the complexity of build scripts and tools like CMake, Make, or Bazel, making it easier to manage large-scale projects.

6. Language-level Support for Modularity

With the introduction of modules, modularity becomes a first-class citizen in the C++ language. This means that the compiler can enforce and assist in maintaining modular boundaries, ensuring stronger modularity compared to the old header system.

7. Cleaner and More Readable Code

By eliminating the need for #include directives and header guards, and by providing a clear separation between module interfaces and implementations, modules help make code more readable. This also reduces boilerplate code and keeps the source files focused on the actual logic rather than managing includes.

Detailed Examples of C++20 Modules

Let’s look at a few examples to understand how modules work in C++20 and how they differ from the traditional header/include system.

Example 1: Defining and Using a Module

Here’s a simple module definition that exports a few functions for mathematical operations.

// MathModule.ixx
export module MathModule;

export int add(int a, int b) {
    return a + b;
}

export int multiply(int a, int b) {
    return a * b;
}

int subtract(int a, int b) {
    return a - b;  // This is internal, not exported
}

In the above module:

• add and multiply are exported and can be used by any file that imports the module.

• subtract is internal to the module and cannot be accessed from outside.

Now, we can use this module in our main program:

// Main.cpp
import MathModule;

#include <iostream>

int main() {
    std::cout << "Add: " << add(5, 3) << std::endl;
    std::cout << "Multiply: " << multiply(4, 2) << std::endl;
}

To compile this:

g++ -std=c++20 -fmodules-ts MathModule.ixx Main.cpp -o main

This example demonstrates how modules can be imported rather than included, and how the compiler manages the interface and implementation.

Example 2: Module with Class and Namespace

Modules can also be used with classes and namespaces. Here’s an example of a module that defines a class:

// Geometry.ixx
export module Geometry;

export namespace shapes {
    class Rectangle {
    public:
        Rectangle(int w, int h) : width(w), height(h) {}
        int area() const {
            return width * height;
        }
    private:
        int width, height;
    };
}

We can now import this module in another file:

// Main.cpp
import Geometry;

#include <iostream>

int main() {
    shapes::Rectangle rect(10, 5);
    std::cout << "Area of rectangle: " << rect.area() << std::endl;
}

This module hides the implementation details of the Rectangle class while exposing the interface.

C++20 modules represent a significant leap forward for the C++ language, offering numerous advantages over the traditional header/include system:

1. Faster Compilation Times: Modules are processed only once, leading to faster incremental builds.

2. Cleaner Code and Better Encapsulation: Modules offer a clear separation between the interface and implementation.

3. Elimination of Header Problems: No need for macros, header guards, or inclusion issues.

4. Improved Dependency Management: Changes to implementation details no longer cause widespread recompilation.

5. Simplified Build Systems: Modules reduce the complexity of build systems in large projects.

6. Language-level Modularity: Stronger enforcement of modular boundaries by the compiler.

7. More Readable Code: Modules help reduce boilerplate code and provide a cleaner project structure.

As compilers and build systems improve their support for C++20 modules, the feature will likely become the standard for modern C++ development, simplifying both small-scale and large-scale projects while maintaining C++'s unmatched power and flexibility.