How do we transform this code so that it uses modules? Just replace the #include<\/tt> preprocessor directive with an import<\/tt> directive.<\/p>\n The std.core<\/tt> module provides most of the content of the C++ Standard Library. The library is modularized as follows:<\/p>\n To be able to use the modularized version of the Standard Library you must install the component called C++ Modules for v142 build tools<\/strong> shown in the following image: \nWhen importing the Standard Library you should build with the \/MD<\/a> and \/EHsc<\/a> options.\n<\/p>\n To build the code snippet above, open a Developer Command Prompt from Visual Studio, and execute the following command:<\/p>\n Now, if you run main.exe<\/strong>, you get the expected result:<\/p>\n Instead of just printing a greeting text in main()<\/tt>, we could get that text from a function. In the following example, this function called get_greeting_text()<\/tt> is exported from a module called greetings<\/tt>. This module is defined in an module interface unit<\/em> called greetings.ixx<\/strong>.<\/p>\n \nThe .ixx<\/strong> extension is required by the VC++ compiler for module interface units.\n<\/p>\n The main.cpp<\/strong> file needs to change slightly to import the greetings<\/tt> module and invoke the get_greeting_text()<\/tt> function.<\/p>\n Now, you need to build both greetings.ixx<\/strong> and main.cpp<\/strong>. The following commands must be executed:<\/p>\n Let’s add more to the greetings<\/tt> module. In the following snippet, greeter<\/tt> is a class with an overloaded call operator that, when invoked, returns a random greeting text.<\/p>\n In main.cpp<\/strong> we will have the following:<\/p>\n The commands for compiling this code remain the same. However, each time we execute the program now a different text will be printed to the console.<\/p>\n Modules can be split into partitions. Partitions help to organize the code of a module, especially if the module is large. Partitions are not exported as stand-alone units but as parts of a module interface unit.<\/p>\n To exemplify module partitions, let’s split the code of the greetings modules into two partitions: one that contains the free functions, called greetings-func<\/strong> and one that contains the classes, called greetings-types<\/strong>. These are also available in files with the extension .ixx. Here is how the look:<\/p>\n The content of greetings-func.ixx<\/strong> is:<\/p>\n The content of greetings-types.ixx<\/strong> is:<\/p>\n The syntax for exporting a module partitions is export module <module-name>:<partition-name><\/tt>. The rest is no different than regular module interface units.<\/p>\n These two partitions are then imported and re-exported from the module interface unit, greetings.ixx<\/strong> as follows:<\/p>\n The syntax for exporting a partition is export import :<partition-name><\/tt>. Of course, apart from these directives, the module interface unit may contain any other exports.<\/p>\n The content of main.cpp<\/strong> does not change. However, we need to change the commands we use to build the code, as follows:<\/p>\n Building this way is possible because we leveraged a naming scheme supported by the VC++ compiler for module partition units. That is <module-name>-<partition-name>.ixx<\/strong>. If you do not follow this scheme, then you need to use the \/module:reference<\/tt> switch to specify the module partition interfaces.<\/p>\n A partition does not have to be an interface unit. It could contain code that is not supposed to be exported from the module. Such a partition is called an internal partition and must be put in a file with the extension .cpp<\/strong>. <\/p>\n To see how these work, let’s modify the previous example where we used the rand()<\/tt> function in the greeter<\/tt> class. We will remove the details of generating a new integer to another function called next_rand()<\/tt> available in an internal partition called greetings:details<\/strong>. This function is not exported from the greetings<\/strong> module. The content of greetings-details.cpp<\/strong> is shown in the following snippet:<\/p>\n We need to modify the code in the greetings:types<\/strong> partition as follows (notice the import :details<\/tt> directive):<\/p>\n Nothing else needs to change except for the build commands. We have a new file to build, greetings-details.cpp<\/strong> and it requires a new compiler switch, \/module:internalPartition<\/tt> to indicate that the file that is compiled is an internal partion of a module.<\/p>\n Now, we can change the implementation details of the next_rand()<\/tt> function without affecting the module interface.<\/p>\n To build the program we only need to run the following commands:<\/p>\n What if the get_greeting_text()<\/tt> was already available in a header file, which perhaps you cannot modularize, maybe because you do not own the code? Modules support the importing of a special translation unit called header unit<\/em>. <\/p>\n Suppose the header, called greetings.h<\/strong> looks like this:<\/p>\n We can import this using the same import<\/tt> directive, as shown in the below snippet:<\/p>\n To build the program, this time, the build commands must be the following:<\/p>\n There are several compiler switches used here:<\/p>\nimport std.core;\r\n\r\nint main()\r\n{\r\n std::cout << \"Hello, World!\\n\";\r\n}<\/pre>\n\n
\n![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2020\/05\/modules1.png\")
<\/p>\ncl \/std:c++latest \/EHsc \/experimental:module \/MD main.cpp<\/pre>\n
![\"\"](\"https:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2020\/05\/modulesout1.png\")
<\/p>\nWriting a module<\/h2>\n
export module greetings;\r\n\r\nimport std.core;\r\n\r\nexport std::string get_greeting_text()\r\n{\r\n return \"Hello, World!\";\r\n}<\/pre>\nimport std.core;\r\nimport greetings;\r\n\r\nint main()\r\n{\r\n std::cout << get_greeting_text() << '\\n';\r\n}<\/pre>\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD main.cpp greetings.obj<\/pre>\n
\r\nexport module greetings;\r\n\r\nimport std.core;\r\n\r\nexport std::string get_greeting_text()\r\n{\r\n return \"Hello, World!\";\r\n}\r\n\r\nexport struct greeter\r\n{\r\n constexpr static const char* hellos[] {\"Hello\", \"Hi\", \"Hey\"};\r\n std::string operator()()\r\n {\r\n return hellos[rand() % 3] + std::string{\", World!\"};\r\n }\r\n};<\/pre>\nimport std.core;\r\nimport greetings;\r\n\r\nint main()\r\n{ \r\n std::cout << get_greeting_text() << '\\n';\r\n \r\n std::cout << greeter()() << '\\n';\r\n}<\/pre>\nComposing a module from partitions<\/h2>\n
export module greetings:func;\r\n\r\nexport const char* get_greeting_text()\r\n{\r\n return \"Hello, World!\";\r\n}<\/pre>\nmodule;\r\n\r\n#include <cstdlib>\r\n\r\nexport module greetings:types;\r\n\r\nimport std.core;\r\n\r\nexport struct greeter\r\n{\r\n constexpr static const char* hellos[] {\"Hello\", \"Hi\", \"Hey\"};\r\n std::string operator()()\r\n {\r\n return hellos[rand() % 3] + std::string{\", World!\"};\r\n }\r\n};<\/pre>\nexport module greetings;\r\n\r\nexport import :func;\r\nexport import :types;<\/pre>\n
cl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings-func.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings-types.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD main.cpp greetings-func.obj greetings-types.obj<\/pre>\n
Internal partitions<\/h2>\n
module;\r\n\r\n#include <cstdlib>\r\n\r\nmodule greetings:details;\r\n\r\nint next_rand()\r\n{\r\n return rand();\r\n}<\/pre>\nexport module greetings:types;\r\n\r\nimport std.core;\r\nimport :details;\r\n\r\nexport struct greeter\r\n{\r\n constexpr static const char* hellos[] {\"Hello\", \"Hi\", \"Hey\"};\r\n std::string operator()()\r\n {\r\n return hellos[next_rand() % 3] + std::string{\", World!\"};\r\n }\r\n};<\/pre>\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings-func.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/module:internalPartition \/MD \/c greetings-details.cpp\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings-types.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/c greetings.ixx\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD main.cpp greetings-func.obj greetings-types.obj greetings-details.obj<\/pre>\n
module greetings:details;\r\n\r\nimport std.core;\r\n\r\nint next_rand()\r\n{\r\n static std::random_device rd{};\r\n static std::mt19937 eng{rd()};\r\n static std::uniform_int_distribution<> uid {0, 1000};\r\n return uid(eng);\r\n}<\/pre>\ncl \/std:c++latest \/EHsc \/experimental:module \/module:internalPartition \/MD \/c greetings-details.cpp\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD main.cpp greetings-func.obj greetings-types.obj greetings-details.obj<\/pre>\n
Importing header units<\/h2>\n
#pragma once\r\n\r\ninline const char* get_greeting_text()\r\n{\r\n return \"Hello, World!\";\r\n}<\/pre>\nimport std.core;\r\nimport \"greetings.h\";\r\n\r\nint main()\r\n{ \r\n std::cout << get_greeting_text() << '\\n';\r\n}\r\n<\/pre>\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/module:exportHeader greetings.h \/Fogreetings.h.obj\r\ncl \/std:c++latest \/EHsc \/experimental:module \/MD \/module:reference greetings.h:greetings.h.ifc main.cpp greetings.h.obj<\/pre>\n
\n