![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/09\/TimelineCpp20Modules.png\")
<\/p>\nIn the last weeks, I learned something new about modules in C++20: private modules fragments and header units. Consequently, I make a short detour in this post and present these new features.<\/p>\n
<\/p>\n
\u00a0<\/p>\n
You may wonder why I didn’t complete my promised post about variadic templates. The reason is simple. The next pdf-bundle<\/a> I publish next week is about C++20 modules, and I want to incorporate this post in this bundle. Before I do that, I have to write this post.<\/p>\n Private module fragments and header units make dealing with modules in C++20 way more comfortable.<\/p>\n I intentionally use the newest Visual Studio compiler in this post because its C++20 modules support is almost complete. The newest GCC and Clang only partially support modules.<\/p>\n I’m unsure if you have the facts about the module interface unit and implementation unit ready. Therefore, let me repeat the essential facts.<\/p>\n When you want to separate your module into an interface and an implementation, you should structure it into a module interface unit and one or more module implementation units.<\/p>\n <\/p>\n <\/p>\n <\/p>\n Manually building the executable includes a few steps.<\/p>\n <\/p>\n You should specify the exception handling model (\/EHsc) for the Microsoft compiler.\u00a0 Additionally, use the flag\u00a0\/std:c++latest<\/span><\/a>.<\/p>\n Finally, here is the output of the program:<\/p>\n One of the significant advantages of structuring modules into a module interface unit and one or more module implementation units is that modifications in the module implementation units do not affect the module interface unit and, therefore, require no recompilation.<\/p>\n Thanks to a private module fragment, you can implement a module in one file and declare its last part as its implementation using <\/p>\n I already presented header units in a previous post. Now, I can use them<\/p>\n Header units are a smooth way to transition from headers to modules. You have to replace the First, import<\/span> respects the same lookup rules as include<\/span>. This means in the case of the quotes (“myHeader.h”<\/span>), the lookup first searches in the local directory before it continues with the system search path.<\/p>\n Second, this is way more than text replacement. In this case, the compiler generates something module-like from the import directive and treats the result as a module. The importing module statement gets all exportable names for the header. The exportable names include macros. Importing these synthesized header units is faster and comparable in speed to precompiled headers<\/a>.<\/p>\n Precompiled headers are a non-standardized way to compile headers in an intermediate form that is faster to process for the compiler. The Microsoft compiler uses the extension After this short remainder, let me try it out.<\/p>\n The following example consists of three files. The header file <\/p>\n Only the implementation file <\/p>\n<\/span>
private<\/code> Module Fragment<\/span><\/h2>\n<\/span>Module Interface Unit<\/span><\/h3>\n
\n\/\/ mathInterfaceUnit2.ixx<\/span>\n\nmodule; \n\n#include <vector> \n\nexport<\/span> module math; \n\nexport<\/span> namespace<\/span> math {\n\n int<\/span> add(int<\/span> fir, int<\/span> sec);\n \n int<\/span> getProduct<\/span>(const<\/span> std::<\/span>vector<<\/span>int<\/span>>&<\/span> vec);\n\n}\n<\/pre>\n<\/div>\n\n
<\/span>Module Implementation Unit<\/span><\/h3>\n
\n\/\/ mathImplementationUnit2.cpp<\/span>\n\nmodule math;\n\n#include <numeric><\/span>\n\nnamespace<\/span> math {\n\n int<\/span> add(int<\/span> fir, int<\/span> sec){\n return<\/span> fir +<\/span> sec;\n }\n\n int<\/span> getProduct(const<\/span> std::<\/span>vector<<\/span>int<\/span>>&<\/span> vec) {\n return<\/span> std::<\/span>accumulate(vec.begin(), vec.end(), 1<\/span>, std::<\/span>multiplies<<\/span>int<\/span>><\/span>());\n }\n}\n<\/pre>\n<\/div>\n\n
<\/span>Main Program<\/span><\/h3>\n
\n\/\/ client4.cpp<\/span>\n\n#include <iostream>\n#include <vector>\n\nimport math;\n\nint<\/span> main<\/span>() {\n \n std::<\/span>cout <<<\/span> std::<\/span>endl; \n \n std::<\/span>cout <<<\/span> \"math::add(2000, 20): \"<\/span> <<<\/span> math::<\/span>add(2000<\/span>, 20<\/span>) <<<\/span> std::<\/span>endl;\n \n std::<\/span>vector<<\/span>int<\/span>><\/span> myVec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>};\n \n std::<\/span>cout <<<\/span> \"math::getProduct(myVec): \"<\/span> <<<\/span> math::<\/span>getProduct(myVec) <<<\/span> std::<\/span>endl;\n \n std::<\/span>cout <<<\/span> std::<\/span>endl;\n \n}\n<\/pre>\n<\/div>\n\n
\n<\/span><\/li>\n<\/ul>\n<\/span>Building the Executable<\/span><\/h3>\n
\ncl.exe \/<\/span>std:<\/span>c++<\/span>latest \/<\/span>c mathInterfaceUnit2.ixx \/<\/span>EHsc \/\/ (1)<\/span>\ncl.exe \/<\/span>std:<\/span>c++<\/span>latest \/<\/span>c mathImplementationUnit2.cpp \/<\/span>EHsc \/\/ (2)<\/span>\ncl.exe \/<\/span>std:<\/span>c++<\/span>latest \/<\/span>c client4.cpp \/<\/span>EHsc \/\/ (3)<\/span>\ncl.exe client4.obj mathInterfaceUnit2.obj mathImplementationUnit2.obj \/\/ (4)<\/span>\n<\/pre>\n<\/div>\n\n
![\"client4\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/09\/client4.png\")
<\/p>\n<\/span>
Private<\/code> Module Fragment<\/span><\/h3>\nmodule :private;<\/code>. Consequently, a modification of the private module fragment does not cause recompilation. The following module declaration file mathInterfaceUnit3.ixx<\/code> refactors the module interface unit mathInterfaceUnit2.ixx<\/code> and the module implementation unit mathImplementationUnit2.cpp<\/code> into one file.<\/p>\n\n\/\/ mathInterfaceUnit3.ixx<\/span>\n\nmodule; \n\n#include <numeric><\/span>\n#include <vector><\/span>\n\nexport<\/span> module math; \n\nexport<\/span> namespace<\/span> math {\n\n int<\/span> add(int<\/span> fir, int<\/span> sec);\n\n int<\/span> getProduct<\/span>(const<\/span> std::<\/span>vector<<\/span>int<\/span>>&<\/span> vec);\n\n}\n\nmodule :<\/span>private<\/span>; \/\/ (1)<\/span>\n\nint<\/span> add<\/span>(int<\/span> fir, int<\/span> sec) {\n return<\/span> fir +<\/span> sec;\n}\n\nint<\/span> getProduct<\/span>(const<\/span> std::<\/span>vector<<\/span>int<\/span>>&<\/span> vec) {\n return<\/span> std::<\/span>accumulate(vec.begin(), vec.end(), 1<\/span>, std::<\/span>multiplies<<\/span>int<\/span>><\/span>());\n}\n<\/pre>\n<\/div>\nmodule: private;<\/code> (line 1) denotes the start of the private<\/code> module fragment. A modification in this optional last part of a module declaration file does not cause its recompilation.<\/p>\n<\/span>Header Units<\/span><\/h2>\n
#include<\/code> directive with the new import<\/code> statement.<\/p>\n\n#include <vector> => import <vector>;<\/span>\n#include \"myHeader.h\" => import \"myHeader.h\"; <\/span>\n<\/pre>\n<\/div>\n<\/span>Modules are not Precompiled Header<\/span><\/h3>\n
.pch<\/code> , and the GCC compiler .gch<\/code> for precompiled headers. The main difference between precompiled headers and modules is that modules can selectively export names. Only in a module are exported names visible outside the module.<\/p>\n<\/span>Use of Header Units<\/span><\/h3>\n
head.h<\/code>, declaring the function hello<\/code>, its implementation file head.cpp<\/code>, defining the function hello<\/code>, and the client file helloWorld3.cpp<\/code> using the function hello<\/code>.<\/p>\n\n\/\/ head.h<\/span>\n\n#include <iostream><\/span>\n\nvoid<\/span> hello<\/span>();\n<\/pre>\n<\/div>\nhead.cpp<\/code> and the client file helloWorld3.cpp<\/code> are special. They import the header file head.h: import \"head.h\";.<\/code><\/p>\n\n\/\/ head.cpp<\/span>\n\nimport \"head.h\"<\/span>;\n\nvoid<\/span> hello<\/span>() {\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n std::<\/span>cout <<<\/span> \"Hello World: header units<\/span>