Header Units

Header units in C++20 are a bridge between traditional header files and modern modules. They allow you to import existing header files as if they were modules, facilitating the integration of legacy code with new module-based code.

To create a header unit, you use the import statement with the header file enclosed in quotes. This tells the compiler to treat the header file as a module-like entity. Here's an example:

1// Player.h
2#pragma once
3#include <iostream>
4#include <string>
5
6class Player {
7 public:
8  Player(const std::string &name) : name{name} {}
9  void sayHello() const {
10    std::cout << "Hello, my name is " << name;
11  }
12
13 private:
14  std::string name;
15};

1// main.cpp
2import "Player.h";
3
4int main() {
5  Player player{"John"};
6  player.sayHello();
7}

1Hello, my name is John

• Seamless Integration: Header units allow you to gradually transition from traditional headers to modules without rewriting all existing code.
• Improved Compile Times: While not as efficient as pure modules, header units can still improve compile times by allowing the compiler to preprocess headers more efficiently.
• Simplified Syntax: Using import instead of #include can simplify the dependency graph of your project, making it easier to manage and understand.

• Compiler Support: Not all compilers fully support header units yet, and the implementation details may vary between compilers.
• Mixed Approaches: Using both header units and traditional #include directives can sometimes lead to inconsistencies and require careful management.

Suppose you have a legacy project that heavily relies on traditional headers. You can start by converting some of these headers into header units:

1// Utilities.h
2#pragma once
3#include <iostream>
4#include <string>
5
6void printMessage(const std::string &message) {
7  std::cout << message << "\n";
8}

1// main.cpp
2import "Utilities.h";
3
4int main() {
5  printMessage("Hello from header unit!");
6}

1Hello from header unit!

Header units in C++20 provide a way to import traditional header files as modules, enabling smoother integration of legacy code with new module-based projects.

They offer improved compile times and a cleaner syntax, although they come with some limitations in terms of compiler support and mixed usage.