{"id":5901,"date":"2020-05-08T10:13:22","date_gmt":"2020-05-08T10:13:22","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/cpp20-modules\/"},"modified":"2023-09-28T06:48:09","modified_gmt":"2023-09-28T06:48:09","slug":"cpp20-modules","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/cpp20-modules\/","title":{"rendered":"C++20: The Advantages of Modules"},"content":{"rendered":"

Modules are one of the four big features of C++20: concepts, ranges, coroutines, and modules. Modules promise a lot: compile-time improvement, isolation of macros, the abolition of header files, and ugly workarounds.<\/p>\n

<\/p>\n

\"\"<\/p>\n

Why do we need modules? I want to step back and describe the steps involved in getting an executable.<\/p>\n

<\/span>A Simple Executable<\/span><\/h2>\n

Of course, I have to start with “Hello World”.<\/p>\n

\n
\/\/ helloWorld.cpp<\/span>\n\n#include <iostream><\/span>\n\nint<\/span> main<\/span>() {\n    std::<\/span>cout <<<\/span> \"Hello World\"<\/span> <<<\/span> std::<\/span>endl;\n}\n<\/pre>\n<\/div>\n
Making an executable helloWorld<\/span> out of the program helloWorld.cpp<\/span> increases its size by a factor 130.<\/p>\n
\"helloWorld\"<\/p>\n
The numbers 100 and 12928 in the screenshot stand for the number of bytes.<\/p>\n
We should have a basic understanding of what’s happening under the hood.<\/p>\n
<\/span>The classical Build Process<\/span><\/h2>\n
The build process consists of three steps: preprocessing, compilation, and linking.<\/p>\n
<\/span>Preprocessing<\/span><\/h3>\n
The preprocessor handles the preprocessor directives such as #include<\/code><\/span> and #define<\/code><\/span>. The preprocessor substitutes #inlude<\/span> directives with the corresponding header files, and it substitutes the macros (#define<\/span>). Thanks to directives such as #if<\/code>, #else<\/code>, #elif<\/code>, #ifdef<\/code>, #ifndef,<\/code> and #endif <\/code>parts of the source code can be included or excluded.<\/p>\n
This straightforward text substitution process can be observed using the compiler flag -E<\/span> on GCC\/Clang, or \/E<\/span> on Windows.<\/p>\n
\"preprocessor\"<\/p>\n
WOW!!! The output of the preprocessing step has more than half a million bytes. I don’t want to blame GCC; the other compilers are similar verbose: CompilerExplorer<\/a>.<\/p>\n
The output of the preprocessor is the input for the compiler.<\/p>\n
<\/span>Compilation<\/span><\/h3>\n
The compilation is separately performed on each output of the preprocessor. The compiler parses the C++ source code and converts it into assembly code. The generated file is called an object file, containing the compiled code in binary form. The object file can refer to symbols that don’t have a definition. The object files can be put in archives for later reuse. These archives are called static libraries.<\/p>\n
The objects or translation units the compiler produces are the input for the linker.<\/p>\n
<\/span>Linking<\/span><\/h3>\n
The linker’s output can be executable, static, or shared library. The linker’s job is to resolve the references to undefined symbols. Symbols are defined in object files or libraries. The typical error in this state is that symbols aren’t defined or defined more than once.<\/p>\n
This build process consisting of the three steps is inherited from C. It works sufficiently well enough if you only have one translation unit. But when you have more than one translation unit, many issues can occur.<\/p>\n
<\/span>Issues of the Build Process<\/span><\/h2>\n
Without any attempt to complete it, the classical build process has flaws. Modules overcome these issues.<\/p>\n
<\/span>Repeated substitution of Headers<\/span><\/h3>\n
The preprocessor substitutes #include<\/span> directives with the corresponding header files. Let me change my initial helloWorld.cpp<\/span> program to make the repetition visible.<\/p>\n
I refactored the program and added two source files hello.cpp<\/span> and world.cpp<\/span>. The source file hello.cpp<\/span> provides the function hello<\/span> and the source file world.cpp<\/span> provides the function world. Both source files include the corresponding headers. Refactoring means that the program does the same such as the previous program helloWorld.cpp.<\/span> The internal structure is changed. Here are the new files:<\/p>\n