Mixing import and include

Yes, you can mix #include directives and import statements in the same file. This flexibility is particularly useful when transitioning existing codebases to C++20 modules. However, there are some best practices and considerations to keep in mind.

When mixing #include and import, the order and placement of these directives matter. #include directives are handled by the preprocessor, which performs a literal copy-paste of the included content.

import statements, on the other hand, are part of the compiler's module system and provide better encapsulation and faster compile times.

Here's an example where we combine both techniques:

1#include <iostream> // Traditional include
2import Math;        // Importing a module
3
4int main() {
5  std::cout << "Result: " << add(2, 3);
6}

1Result: 5

Global Module Fragment: Use a global module fragment to handle #include directives that must appear before the module declaration. This is useful for including headers that define macros or other preprocessor directives.

1module; // Global module fragment
2
3// Legacy include
4#include <SomeLegacyHeader.h> 
5
6export module MyModule;
7import <iostream>;
8
9export void myFunction() {
10  std::cout << "Using both include and import";
11}

Avoid Mixing in Same Scope: Where possible, avoid mixing #include and import within the same scope. This can reduce potential conflicts and improve readability.

1#include <vector>  // Traditional include
2import MyModule;   // Importing a module
3
4int main() {
5  // Use of both imported and included content
6  myFunction();
7  std::vector<int> vec{1, 2, 3};
8  for (int num : vec) {
9    std::cout << num << "\n";
10  }
11}

Transition Gradually: When transitioning to modules, start by converting commonly used headers to header units or modules. Gradually replace #include directives with import statements to maintain compatibility.

• Name Conflicts: Mixing #include and import can sometimes lead to name conflicts. Ensure that names used in different headers and modules do not clash.
• Preprocessor Directives: #include directives introduce preprocessor macros, which are not managed by the module system. This can lead to unexpected behavior if not handled carefully.

Mixing #include directives and import statements in the same file is possible and useful during the transition to C++20 modules. By following best practices and understanding potential issues, you can effectively manage and modernize your codebase.