![\"TimelineCpp20\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/02\/TimelineCpp20.png\")
<\/p>\nSo far, I have written in my last four posts the basics you should know about modules in C++20. Only a few questions about modules are still open. In this post, I address these open questions, such as templates in modules, the linkage of modules, and header units.<\/p>\n
<\/p>\n
<\/p>\n
I assume in this post that you know my previous posts to modules. If not, make yourself comfortable and read the following posts.<\/p>\n
I often hear the question: How do modules export templates? When you instantiate a template, its definitions must be available. This is the reason that template definitions are hosted in headers. Conceptually, the usage of templates has the following structure.<\/p>\n
<\/p>\n
\/\/ templateSum.h<\/span>\r\n
template<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\nauto<\/span> sum(T fir, T2 sec) { \r\n return<\/span> fir +<\/span> sec;\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
\n- sumMain.cpp<\/span><\/li>\n<\/ul>\n
<\/p>\n
\n\/\/ sumMain.cpp<\/span>\r\n\r\n#include <templateSum.h><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n sum(1<\/span>, 1.5<\/span>);\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The main program<\/span> directly includes the header templateSum.h<\/span> into the program sumMain.cpp. <\/span>The call sum(1, 1.5)<\/span> triggers the so-called template instantiation. In this case, the compiler generates the function sum out of the function template, which takes an int<\/span> and a double<\/span>. If you want to see this process live, play with the example on C++ Insights<\/a>. <\/span><\/p>\nWith C++20, templates can and should be in modules. Modules have a unique internal representation that is neither source code nor assembly. This representation is a kind of an abstract syntax tree<\/a> (AST). Thanks to this AST, the template definition is available during template instantiation.<\/p>\nI define the function template sum in the module math in the following example.<\/p>\n
\n- mathModuleTemplate.ixx<\/span><\/li>\n<\/ul>\n
<\/p>\n
\n\/\/ mathModuleTemplate.ixx<\/span>\r\n\r\nexport<\/span> module math; \r\n\r\nexport<\/span> namespace<\/span> math { \r\n\r\n template<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\n auto<\/span> sum(T fir, T2 sec) { \r\n return<\/span> fir +<\/span> sec;\r\n }\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
\n- clientTemplate.cpp<\/span><\/li>\n<\/ul>\n
<\/p>\n
\n\/\/ clientTemplate.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\nimport math;\r\n\r\nint<\/span> main<\/span>() {\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl; \r\n\r\n std::<\/span>cout <<<\/span> \"math::sum(2000, 11): \"<\/span> <<<\/span> math::<\/span>sum(2000<\/span>, 11<\/span>) <<<\/span> std::<\/span>endl;\r\n\r\n std::<\/span>cout <<<\/span> \"math::sum(2013.5, 0.5): \"<\/span> <<<\/span> math::<\/span>sum(2013.5<\/span>, 0.5<\/span>) <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"math::sum(2017, false): \"<\/span> <<<\/span> math::<\/span>sum(2017<\/span>, false<\/span>) <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The command line to compile the program is not different from the previous one in the post “C++20: Structure Modules”.<\/a> Consequently, I skip it and present the output of the program directly:<\/p>\n![\"clientTemplate\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/06\/clientTemplate.png\")
<\/p>\n
With modules, we get a new kind of linkage:<\/p>\n<\/p>\n
Module Linkage<\/h2>\n
So far, C++ supports two kinds of linkage: internal and external.<\/p>\n
\n- Internal linkage<\/strong>: Names with internal linkage are not accessible outside the translation unit. The internal linkage includes mainly namespace-scope names declared static and anonymous namespaces members.<\/li>\n
- External linkage<\/strong>. Names with external linkage are accessible outside the translation unit. The external linkage includes names declared not as static, class types, and their members, variables, and templates.<\/li>\n<\/ul>\n
Modules introduce module linkage:<\/p>\n
\n- Module linkage<\/strong>: Names within module linkage are only accessible inside the module. Names have module linkage if they don’t have internal linkage and are not exported.<\/li>\n<\/ul>\n
A small variation of the previous module math <\/span>makes my point. Imagine I want to return the user of my function template sum <\/span>additionally,<\/span> which type the compiler deduces as the return type.<\/span><\/p>\n\n- mathModuleTemplate1.ixx<\/span><\/li>\n<\/ul>\n
<\/p>\n
\n\/\/ mathModuleTemplate1.ixx<\/span>\r\n\r\nmodule;\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n#include <utility><\/span>\r\n\r\nexport<\/span> module math; \r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T> \/\/ (2)<\/span> <\/span>\r\nauto<\/span> showType(T&&<\/span> t) {\r\n return<\/span> typeid<\/span>(std::forward<T>(t)).name();\r\n}\r\n\r\nexport<\/span> namespace<\/span> math { \/\/ (3)<\/span> \r\n\r\n template<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\n auto<\/span> sum(T fir, T2 sec) {\r\n auto<\/span> res =<\/span> fir +<\/span> sec;\r\n return<\/span> std::<\/span>make_pair(res, showType(res)); \/\/ (1)<\/span> \r\n }\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Instead of the sum of the numbers, the function template sum returns a std::pair<\/span> (1) consisting of the sum and a string representation of the type res<\/span>. I put the function template showType<\/span> (2) not in the exporting namespace math (3). Consequently, invoking it from outside the module math<\/span> is not possible. showType<\/span> uses perfect forwarding<\/a> to preserve the value categories of the function argument t<\/span>. The function typeid<\/span> queries information about the type at run-time (runtime type identification (RTTI)<\/a>).<\/p>\n\n- clientTemplate1.cpp<\/span><\/li>\n<\/ul>\n
<\/p>\n
\n\/\/ clientTemplate1.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\nimport math;\r\n\r\nint<\/span> main<\/span>() {\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl; \r\n \r\n auto<\/span> [val, message] =<\/span> math::<\/span>sum(2000<\/span>, 11<\/span>);\r\n std::<\/span>cout <<<\/span> \"math::sum(2000, 11): \"<\/span> <<<\/span> val <<<\/span> \"; type: \"<\/span> <<<\/span> message <<<\/span> std::<\/span>endl;\r\n \r\n auto<\/span> [val1, message1] =<\/span> math::<\/span>sum(2013.5<\/span>, 0.5<\/span>);\r\n std::<\/span>cout <<<\/span> \"math::sum(2013.5, 0.5): \"<\/span> <<<\/span> val1 <<<\/span> \"; type: \"<\/span> <<<\/span> message1 <<<\/span> std::<\/span>endl;\r\n \r\n auto<\/span> [val2, message2] =<\/span> math::<\/span>sum(2017<\/span>, false<\/span>);\r\n std::<\/span>cout <<<\/span> \"math::sum(2017, false): \"<\/span> <<<\/span> val2 <<<\/span> \"; type: \"<\/span> <<<\/span> message2 <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Now, the program displays the value of the summation and a string representation of the automatically deduced type.<\/p>\n
![\"clientTemplate1\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2020\/06\/clientTemplate1.png\")
<\/p>\n
Neither the GCC compiler nor the Clang compiler supports the next feature, which may become one of the favorite features regarding modules.<\/p>\n
Header Units<\/h2>\n
Header units are a smooth way to transition from headers to modules. You must replace the #include<\/span> directive with a new import<\/span> directive.<\/p>\n <\/p>\n
\n#include <vector> => import <vector>;<\/span>\r\n#include \"myHeader.h\" => import \"myHeader.h\"; <\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
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>\nSecond, 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>\nOne Drawback<\/h3>\n
There is one drawback with header units. Not all headers are importable. Which headers are importable is implementation-defined, but the C++ standard guarantees all standard library headers are importable. The ability to import excludes C headers. They are just wrapped in the std<\/span> namespace. For example, <cstring<\/span>> is the C++ wrapper for <string.h<\/span>>. You can quickly identify the wrapped C header because the pattern is: xxx.h<\/span> <\/strong>becomes cxxx.<\/span> <\/strong><\/p>\nWhat’s next?<\/h2>\n
With this post, I completed my story to modules, and, in particular, I completed my story to the big four in C++20. Here are all existing and upcoming posts to C++20.<\/a> With my next post<\/a>, I will have a closer look at the core language features in C++, which are not so prominent such as concepts or modules. I start with the three-way comparison operator.<\/p>\n <\/p>\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
So far, I have written in my last four posts the basics you should know about modules in C++20. Only a few questions about modules are still open. In this post, I address these open questions, such as templates in modules, the linkage of modules, and header units.<\/p>\n","protected":false},"author":21,"featured_media":5199,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[443],"class_list":["post-5919","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-modules"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5919","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5919"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5919\/revisions"}],"predecessor-version":[{"id":6739,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5919\/revisions\/6739"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5199"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5919"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5919"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5919"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}