{"id":8438,"date":"2023-10-16T07:37:09","date_gmt":"2023-10-16T07:37:09","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=8438"},"modified":"2023-10-28T08:48:41","modified_gmt":"2023-10-28T08:48:41","slug":"c20-module-support-of-the-big-three-compilers","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c20-module-support-of-the-big-three-compilers\/","title":{"rendered":"C++20: Module Support of the Big Three"},"content":{"rendered":"\n

I have written almost 100 posts about C++20<\/a> in the last four years, but I’m not done. This post continues my story about C++20.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Modules are one of the Big Four in C++20. In my C++20 classes, they are one of the main topics. Sadly, the implementation in GCC and Clang was way behind the Microsoft Compiler. Consequentially, I usually used the Microsoft Compiler in my classes, my talks, and books to present modules. I’m happy to say that the module support of GCC and Clang significantly improved. I will, therefore, present the current module implementation state (10\/2023) of the Big Three GCC, Clang, and MSVC in this post.<\/p>\n\n\n\n

If you are not familiar with modules in C++20, here is a simple example:<\/p>\n\n\n\n

A Simple Module<\/h2>\n\n\n\n

This is the module math<\/code>. <\/p>\n\n\n\n

\/\/ math1.ixx<\/span>\n\nmodule;                  \/\/ (1)          <\/span>\n\n#include <numeric><\/span>\n#include <vector><\/span>\n\nexport<\/span> module math;      \/\/ (2) <\/span>\n\nexport<\/span> int<\/span> add<\/span>(int<\/span> fir, int<\/span> sec){\n    return<\/span> fir +<\/span> sec;\n}\n\nexport<\/span> int<\/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><\/div>\n\n\n\n
The global module fragment starts with the keyword module <\/code>(line 1) and ends with the exporting module declaration (line 3). The global module fragment is the place to use preprocessor directives such as #include<\/code> so that the module can compile. Preprocessor entities used inside the global module fragment are only visible inside the module. The module math <\/code>exports the two functions add <\/code>and getProduct<\/code>.<\/p>\n\n\n\n
 The client imports the module math <\/code>(line 1) and uses its functionality:<\/p>\n\n\n\n
\/\/ client1.cpp<\/span>\n\n#include <iostream><\/span>\n#include <vector><\/span>\n\nimport math;                        \/\/ (1)<\/span>\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;   \n   \n    std::<\/span>cout <<<\/span> "add(2000, 20): "<\/span> <<<\/span> add(2000<\/span>, 20<\/span>) <<<\/span> '\\n'<\/span>;\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> "getProduct(myVec): "<\/span> <<<\/span> getProduct(myVec) <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n   \n}\n<\/pre><\/div>\n\n\n\n
Finally, this is the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Of course, there is a lot more to modules you should know. I suggest that you read the following posts:<\/p>\n\n\n\n
    \n
  1. The Advantages of Modules<\/a><\/li>\n\n\n\n
  2. A Simple math Modul<\/a><\/li>\n\n\n\n
  3. Module Interface Unit and Module Implementation Unit<\/a><\/li>\n\n\n\n
  4. Structure Modules<\/a><\/li>\n\n\n\n
  5. Open Questions to Modules<\/a><\/li>\n\n\n\n
  6. Private Module Fragment and Header Units<\/a><\/li>\n<\/ol>\n\n\n\n
    I started with a simple module, and I will make it even more simple when I discuss the module implementation state of GCC, Clang, and MSVC.<\/p>\n\n\n\n
    Implementation State<\/h2>\n\n\n\n
    math.ixx<\/code> defines the module math<\/code>, I will use it in the following comparison.<\/p>\n\n\n\n
    \/\/ math.ixx<\/span>\n\nexport<\/span> module math;     \/\/ (1)<\/span>\n\nexport<\/span> int<\/span> add<\/span>(int<\/span> fir, int<\/span> sec){\n    return<\/span> fir +<\/span> sec;\n}\n<\/pre><\/div>\n\n\n\n
    Additionally, here is the client program client.cpp <\/code>importing the module math<\/code>.<\/p>\n\n\n\n
    \/\/ client.cpp<\/span>\n\nimport math;       \/\/ (2)<\/span>\n\nint<\/span> main<\/span>() {\n   \n   add(2000<\/span>, 20<\/span>);\n   \n}\n<\/pre><\/div>\n\n\n\n
    Line (1) is the exporting module declaration, and line (2) imports the module. For obvious reasons, I will not show you the program’s output. <\/p>\n\n\n\n
    First, you may wonder why I called the module declaration file math.ixx<\/code>. Here is the first irritating point.<\/p>\n\n\n\n
    Module Declaration File<\/h3>\n\n\n\n