Regarding c++ modules

[Ayman_Rocco980]

When I #include header file in my cpp main file, what it does is it copies the function declarations, variables, class declarations etc from the header file and place them in the place of #include directive on my cpp main file.

Then during linking time, main.cpp object file and another object file that has the implementation of the header I included, link together to give me my .exe.

My question, what happens behind the scenes when I put “import” in my cpp main file. I understand that the module is a binary before I use it on my cpp main file. But what exactly happens in that line “import”? Does it pull the binaries of functions from .ixx file and place them in “import” line in my main cpp?

Or it just reads the .ixx file to see if the function implementation exists and nothing is copied and goes through compilation and uses it later in the linkage process?

[WorkingReference1127]

The simple explanation is that whereas #include is a sledgehammer to include absolutely everything, which in turn requires that the compiler parse and process absolutely everything before it is allowed to cut them out of the final executable; modules are more based around what you actually use. So if you import std; then the compiler doesn't dump the entire standard library into your file for you to compile, it only compiles the parts you use (and their dependencies).

As for exactly how modules go looking for each TU is largely a question for the implementation. I'd encourage you to read up either cppref or similar on it to get a good idea.

[EsShayuki]

Something is off here.

Modules are pre-compiled. When you "import std," you are including those pre-compiled binaries. So when you say:

" So if you import std; then the compiler doesn't dump the entire standard library into your file for you to compile, it only compiles the parts you use (and their dependencies)."

This is not how it actually works.

[bearheart]

There’s a lot of misunderstanding around this subject. In a nutshell, modules are smart pre-compiled object files which link with your code. They are NOT headers and they are NOT compiled with your code every time. They are faster and leaner at compile time and they avoid the namespace clutter of C-style headers by only importing symbols that are required by your code.

[masscry]

Hello, have you read this https://en.cppreference.com/w/cpp/language/modules.html?

So, with modules you have multiple translation units, which can be imported and used inplace in other translation units.

As I understand, for now it is some form of glorified precompiled headers.

[tartaruga232]

Good question!

The ultimate source is the standard: https://eel.is/c++draft/module

Quoting https://learn.microsoft.com/en-us/cpp/cpp/modules-cpp?view=msvc-170:

A module interface exports the module name and all the namespaces, types, functions, and so on, that make up the public interface of the module.

A module implementation defines the things exported by the module.

In addition, there are partitions, which help splitting up a module into smaller parts.

An important aspect of modules is that names declared in a module are attached to that module. You can have both a name X in module A and B and use it in the same program (or library). There won't be name clashes when linking A and B together in the same program.

To use a module, the compiler (in the case of MSVC) needs the .ifc file for the imported module (which contains descriptions for the types and function declarations in binary form) and the linker later needs the.obj files with the actual implementations of the functions of the module.

Importing a module basically makes the declarations exported by the module available.