WEBKT

C++20 Modules终极指南-告别头文件地狱，迎接高效编译

81 0 0 0

为什么要用Modules？头文件它不香吗？

Modules的优势，一览无余

Modules的基本概念，心中有数

Modules语法，手到擒来

Modules实战，代码说话

Modules进阶，更上一层楼

Modules的局限性，心里有数

Modules的未来，充满期待

C++20 Modules，这玩意儿，对于咱们这些天天跟编译器打交道的码农来说，简直就是救星般的存在。想想以前，为了个头文件包含顺序，抓耳挠腮，debug到天亮，现在有了Modules，嘿，感觉整个世界都清净了。今天咱们就来好好聊聊C++20 Modules，看看它到底能给咱们带来什么，以及怎么用它来更好地组织和管理大型项目。

为什么要用Modules？头文件它不香吗？

头文件这套机制，从C语言开始就有了，也用了这么多年，按理说应该挺成熟的。但问题就出在这“成熟”上。头文件的问题，主要有这么几个：

  1. 编译效率低下：#include 实际上就是把头文件的内容复制粘贴到源文件中。大型项目里，头文件嵌套包含是常有的事，这会导致大量的重复编译，浪费时间。
  2. 命名空间污染：所有 #include 的符号都会进入全局命名空间，容易造成命名冲突。
  3. 脆弱性：头文件之间存在依赖关系，修改一个头文件，可能会导致大量源文件需要重新编译。这种依赖关系隐藏在代码中，难以维护。
  4. 宏的滥用：宏定义是C/C++里一把双刃剑，用好了能提高效率，用不好就是灾难。头文件里大量的宏定义，会使得代码难以理解和调试。

Modules就是为了解决这些问题而生的。它通过模块化编译，避免了头文件的重复包含，提高了编译效率；通过显式声明模块的接口，避免了命名空间污染；通过隐藏模块的实现细节，降低了模块间的耦合度。

Modules的优势，一览无余

说了这么多，Modules到底有哪些优势呢？咱们来一条条列清楚：

  1. 更快的编译速度：这是Modules最直接的优势。模块只会被编译一次，之后编译器可以直接使用编译好的模块，无需重复解析头文件。对于大型项目，编译速度的提升非常明显。
  2. 更强的封装性：Modules可以显式地声明哪些符号是导出的，哪些是隐藏的。这使得我们可以更好地控制模块的接口，避免暴露不必要的实现细节。
  3. 更好的代码组织：Modules可以将代码组织成逻辑单元，使得代码结构更清晰，更易于理解和维护。
  4. 避免宏污染：Modules不会受到宏定义的影响，这使得我们可以更安全地使用宏，而不用担心宏定义会影响到其他模块。
  5. 更强的依赖管理：Modules可以显式地声明模块间的依赖关系，编译器可以根据这些依赖关系来优化编译顺序，避免循环依赖等问题。

Modules的基本概念，心中有数

要使用Modules，首先要理解几个基本概念：

  • Module Unit：模块单元，是构成一个模块的基本编译单元。一个模块可以由多个模块单元组成。模块单元可以是模块接口单元（Module Interface Unit）或模块实现单元（Module Implementation Unit）。
  • Module Interface Unit：模块接口单元，定义了模块的公共接口。它声明了哪些符号可以被其他模块使用。模块接口单元通常以 .ixx 或 .mpp 为后缀。
  • Module Implementation Unit：模块实现单元，实现了模块的具体功能。它可以访问模块接口单元中声明的符号，但不能被其他模块直接访问。模块实现单元通常以 .cpp 为后缀。
  • Global Module Fragment：全局模块片段，是在模块接口单元或模块实现单元中，位于任何模块声明之前的代码。全局模块片段中的代码会被视为全局代码，可以访问全局命名空间中的符号。
  • Module Partition：模块分区，将一个模块分割成多个独立的编译单元。模块分区可以提高编译速度，并使得我们可以更好地组织大型模块。模块分区可以是模块接口分区（Module Interface Partition）或模块实现分区（Module Implementation Partition）。

Modules语法，手到擒来

了解了基本概念，接下来咱们来看看Modules的具体语法：

  1. 模块声明：使用 module 关键字来声明一个模块。例如：
// my_module.ixx
module my_module;
 
export int add(int a, int b);
  1. 导出声明：使用 export 关键字来声明一个符号可以被其他模块使用。例如：
// my_module.ixx
module my_module;
 
export int add(int a, int b);
 
int add(int a, int b) {
  return a + b;
}
  1. 导入声明：使用 import 关键字来导入其他模块。例如：
// main.cpp
import my_module;
 
int main() {
  int result = add(1, 2);
  return 0;
}
  1. 模块分区：使用 module :partition 关键字来声明一个模块分区。例如：
// my_module.ixx
module my_module;
 
export module my_module:math;
export int add(int a, int b);
 
// my_module-math.ixx
module my_module:math;
 
int add(int a, int b) {
  return a + b;
}

Modules实战，代码说话

光说不练假把式，咱们来个实际的例子，看看怎么用Modules来组织一个简单的项目。假设我们要开发一个简单的数学库，包含加法和乘法两个功能。

  1. 创建模块接口单元：创建一个名为 math.ixx 的文件，声明模块的公共接口：
// math.ixx
module math;
 
export int add(int a, int b);
export int multiply(int a, int b);
  1. 创建模块实现单元：创建一个名为 math.cpp 的文件，实现模块的具体功能：
// math.cpp
module math;
 
int add(int a, int b) {
  return a + b;
}
 
int multiply(int a, int b) {
  return a * b;
}
  1. 创建主程序：创建一个名为 main.cpp 的文件，使用数学库的功能：
// main.cpp
import math;
import <iostream>;
 
int main() {
  int sum = add(1, 2);
  int product = multiply(3, 4);
 
  std::cout << "Sum: " << sum << std::endl;
  std::cout << "Product: " << product << std::endl;
 
  return 0;
}
  1. 编译项目：使用支持C++20 Modules的编译器来编译项目。例如，使用g++编译器：
g++ -std=c++20 -fmodules-ts -c math.cpp -o math.o
g++ -std=c++20 -fmodules-ts -c math.ixx -o math.mod
g++ -std=c++20 -fmodules-ts -c main.cpp -o main.o
g++ -std=c++20 -fmodules-ts main.o math.o math.mod -o main
  1. 运行程序：运行编译好的程序，可以看到输出结果：
Sum: 3
Product: 12

Modules进阶，更上一层楼

掌握了Modules的基本用法，咱们再来看看一些高级技巧：

  1. 使用模块分区：对于大型模块，可以使用模块分区来提高编译速度。例如，将数学库分成加法模块和乘法模块：
// math.ixx
module math;
 
export module math:add;
export module math:multiply;
 
// math-add.ixx
module math:add;
 
export int add(int a, int b);
 
// math-multiply.ixx
module math:multiply;
 
export int multiply(int a, int b);
 
// math-add.cpp
module math:add;
 
int add(int a, int b) {
  return a + b;
}
 
// math-multiply.cpp
module math:multiply;
 
int multiply(int a, int b) {
  return a * b;
}
  1. 使用 export import：可以使用 export import 语句来重新导出其他模块。例如：
// module_a.ixx
module module_a;
 
export int foo();
 
// module_b.ixx
module module_b;
 
export import module_a;
 
// main.cpp
import module_b;
 
int main() {
  int result = foo(); // 可以直接使用module_a中的foo函数
  return 0;
}

  1. Private Module Fragment

    使用 module :private 可以在模块内部定义一些私有的实现细节，这些细节不会被导出到模块的接口中。这可以帮助我们更好地封装模块的实现细节，提高代码的可维护性。

    		// my_module.ixx
    		module my_module;
    		 
    		export int public_function();
    		 
    		module :private {
    		  int private_function();
    		}
    		 
    		// my_module.cpp
    		module my_module;
    		 
    		int public_function() {
    		  return private_function();
    		}
    		 
    		module :private {
    		  int private_function() {
    		    return 42;
    		  }
    		}

Modules的局限性，心里有数

Modules虽然有很多优势，但也有一些局限性：

  1. 编译器支持：目前，并非所有编译器都完全支持C++20 Modules。在使用Modules之前，需要确认编译器是否支持。
  2. 构建系统集成：Modules需要构建系统的支持才能正常工作。需要修改构建脚本，才能正确编译和链接模块。
  3. 学习成本：Modules引入了一些新的概念和语法，需要一定的学习成本才能掌握。
  4. 与现有代码的兼容性：将现有代码迁移到Modules需要一定的工作量。需要修改头文件和源文件，才能使其与Modules兼容。

Modules的未来，充满期待

虽然Modules目前还存在一些局限性，但它的优势是显而易见的。随着编译器和构建系统对Modules的支持越来越完善，相信Modules将会成为C++开发的主流方式。它可以帮助我们更好地组织和管理大型项目，提高编译效率，并改善代码的可维护性。

对于咱们这些C++开发者来说，学习和掌握Modules是非常有必要的。它可以让我们在未来的开发工作中更加高效和轻松。

所以，别再犹豫了，赶紧拥抱C++20 Modules吧！

代码老司机 C++20Modules编译优化

评论点评

打赏赞助
sponsor

感谢您的支持让我们更好的前行

分享

QRcode

https://www.webkt.com/article/9342