CMake与NMake构建工具详解跨平台项目构建中的黄金搭档如何协同工作提升开发效率

威震华夏关云长

引言

构建工具是软件开发过程中不可或缺的一部分，它们负责自动化编译、链接和其他构建过程，帮助开发者管理复杂的项目。在跨平台开发中，选择合适的构建工具尤为重要。CMake和NMake是两个广泛使用的构建工具，它们各自具有独特的优势，当它们协同工作时，能够显著提高跨平台项目的开发效率。

CMake详解

CMake是一个跨平台的构建系统生成器，它使用简单的配置文件（CMakeLists.txt）来生成标准的构建文件（如Makefile、Visual Studio项目等）。CMake的主要优势在于其跨平台性和灵活性。

CMake的特点

• 跨平台：支持Windows、Linux、macOS等多种操作系统
• 多生成器：可以生成各种构建系统的配置文件，如Unix Makefiles、Ninja、Visual Studio等
• 简单语法：使用简单的CMake语言编写构建脚本
• 模块化：支持模块化设计，便于代码复用
• 强大的依赖管理：可以自动处理依赖关系

CMake基本语法

CMake使用CMakeLists.txt文件来定义构建规则。以下是一个简单的CMakeLists.txt示例：

2. # 指定最低CMake版本要求
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目名称
6. project(MyProject)
8. # 设置C++标准
9. set(CMAKE_CXX_STANDARD 11)
10. set(CMAKE_CXX_STANDARD_REQUIRED ON)
12. # 添加可执行文件
13. add_executable(my_app main.cpp utils.cpp)
15. # 添加头文件搜索路径
16. include_directories(${PROJECT_SOURCE_DIR}/include)
18. # 添加库文件搜索路径
19. link_directories(${PROJECT_SOURCE_DIR}/lib)
21. # 链接库
22. target_link_libraries(my_app pthread)

复制代码

CMake常用命令

• cmake_minimum_required: 指定CMake最低版本要求
• project: 定义项目名称
• add_executable: 添加可执行文件
• add_library: 添加库文件
• include_directories: 添加头文件搜索路径
• link_directories: 添加库文件搜索路径
• target_link_libraries: 链接库文件
• find_package: 查找并加载外部项目设置
• option: 定义构建选项

NMake详解

NMake是Microsoft Visual Studio中包含的构建工具，类似于Unix系统中的make。它读取makefile文件中的规则，并执行相应的命令来构建项目。NMake主要在Windows平台上使用，特别适合大型C/C++项目的构建。

NMake的特点

• Windows平台原生支持：与Windows开发环境紧密集成
• 高效的增量构建：只重新构建修改过的文件
• 强大的依赖管理：自动处理文件依赖关系
• 灵活的宏定义：支持宏定义和替换
• 条件执行：支持条件判断和循环

NMake基本语法

NMake使用makefile文件来定义构建规则。以下是一个简单的makefile示例：

2. # 定义编译器
3. CC = cl
4. CFLAGS = /nologo /W3 /O2
6. # 定义目标
7. TARGET = my_app.exe
9. # 定义源文件
10. SRCS = main.cpp utils.cpp
12. # 定义对象文件
13. OBJS = $(SRCS:.cpp=.obj)
15. # 默认目标
16. all: $(TARGET)
18. # 链接规则
19. $(TARGET): $(OBJS)
20.     $(CC) $(CFLAGS) /Fe$(TARGET) $(OBJS)
22. # 编译规则
23. .cpp.obj:
24.     $(CC) $(CFLAGS) /c $<
26. # 清理规则
27. clean:
28.     del $(OBJS) $(TARGET)

复制代码

NMake常用命令

• nmake /f makefile: 指定makefile文件
• nmake all: 构建所有目标
• nmake clean: 清理生成的文件
• nmake /A: 强制构建所有目标
• nmake /D: 显示依赖关系

CMake与NMake的协同工作

CMake和NMake可以很好地协同工作，CMake负责生成NMake所需的makefile文件，而NMake负责实际的构建工作。这种组合特别适合在Windows平台上进行跨平台开发。

工作流程

1. 编写CMakeLists.txt文件，定义项目的构建规则
2. 使用CMake生成NMake的makefile文件
3. 使用NMake执行实际的构建工作

生成NMake makefile

使用CMake生成NMake makefile的命令如下：

2. # 创建构建目录
3. mkdir build
4. cd build
6. # 生成NMake makefile
7. cmake -G "NMake Makefiles" ..
9. # 使用NMake构建项目
10. nmake

复制代码

CMake与NMake的优势互补

• CMake提供了跨平台的抽象层，使得同一套构建脚本可以在不同平台上工作
• NMake提供了Windows平台上的高效构建能力，特别适合大型项目
• CMake可以自动处理复杂的依赖关系，而NMake可以高效地执行增量构建
• CMake支持多种生成器，可以根据需要选择最适合的构建系统

实战案例

让我们通过一个具体的示例来展示CMake与NMake如何协同工作。假设我们有一个简单的跨平台项目，包含以下文件结构：

2. MyProject/
3. ├── src/
4. │   ├── main.cpp
5. │   └── utils.cpp
6. ├── include/
7. │   └── utils.h
8. └── CMakeLists.txt

复制代码

源代码文件

main.cpp:

2. #include <iostream>
3. #include "utils.h"
5. int main() {
6.     std::cout << "Hello from MyProject!" << std::endl;
7.     printMessage("This is a utility function.");
8.     return 0;
9. }

复制代码

utils.h:

2. #ifndef UTILS_H
3. #define UTILS_H
5. void printMessage(const char* message);
7. #endif // UTILS_H

复制代码

utils.cpp:

2. #include <iostream>
3. #include "utils.h"
5. void printMessage(const char* message) {
6.     std::cout << "Utility message: " << message << std::endl;
7. }

复制代码

CMakeLists.txt文件

2. # 指定最低CMake版本要求
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目名称
6. project(MyProject)
8. # 设置C++标准
9. set(CMAKE_CXX_STANDARD 11)
10. set(CMAKE_CXX_STANDARD_REQUIRED ON)
12. # 添加可执行文件
13. add_executable(my_app
14.     src/main.cpp
15.     src/utils.cpp
16. )
18. # 添加头文件搜索路径
19. target_include_directories(my_app PRIVATE ${PROJECT_SOURCE_DIR}/include)
21. # 设置输出目录
22. set_target_properties(my_app PROPERTIES
23.     RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
24. )

复制代码

使用CMake和NMake构建项目

1. 打开命令提示符，进入项目根目录
2. 创建构建目录并进入：

2. mkdir build
3. cd build

复制代码

1. 使用CMake生成NMake makefile：

2. cmake -G "NMake Makefiles" ..

复制代码

1. 使用NMake构建项目：

2. nmake

复制代码

1. 运行生成的可执行文件：

2. cd bin
3. my_app.exe

复制代码

构建结果

执行上述步骤后，CMake会生成NMake所需的makefile文件，NMake会根据这些文件编译和链接项目，最终生成可执行文件my_app.exe。运行该文件，输出如下：

2. Hello from MyProject!
3. Utility message: This is a utility function.

复制代码

更复杂的示例

让我们考虑一个更复杂的示例，包含多个子项目和外部依赖。

项目结构：

2. MyComplexProject/
3. ├── src/
4. │   ├── main.cpp
5. │   └── utils.cpp
6. ├── include/
7. │   └── utils.h
8. ├── lib/
9. │   └── mylib/
10. │       ├── include/
11. │       │   └── mylib.h
12. │       └── src/
13. │           └── mylib.cpp
14. ├── third_party/
15. │   └── fmt/
16. └── CMakeLists.txt

复制代码

CMakeLists.txt:

2. # 指定最低CMake版本要求
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目名称
6. project(MyComplexProject)
8. # 设置C++标准
9. set(CMAKE_CXX_STANDARD 17)
10. set(CMAKE_CXX_STANDARD_REQUIRED ON)
12. # 添加子目录
13. add_subdirectory(lib/mylib)
15. # 查找fmt库
16. find_package(fmt REQUIRED)
18. # 添加可执行文件
19. add_executable(my_app
20.     src/main.cpp
21.     src/utils.cpp
22. )
24. # 添加头文件搜索路径
25. target_include_directories(my_app PRIVATE
26.     ${PROJECT_SOURCE_DIR}/include
27. )
29. # 链接库
30. target_link_libraries(my_app
31.     PRIVATE
32.     mylib
33.     fmt::fmt
34. )
36. # 设置输出目录
37. set_target_properties(my_app PROPERTIES
38.     RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
39. )

复制代码

lib/mylib/CMakeLists.txt:

2. # 添加库
3. add_library(mylib
4.     src/mylib.cpp
5. )
7. # 添加头文件搜索路径
8. target_include_directories(mylib
9.     PUBLIC
10.     ${CMAKE_CURRENT_SOURCE_DIR}/include
11. )

复制代码

main.cpp:

2. #include <iostream>
3. #include <fmt/format.h>
4. #include "utils.h"
5. #include "mylib.h"
7. int main() {
8.     std::cout << "Hello from MyComplexProject!" << std::endl;
9.     printMessage("This is a utility function.");
10.    
11.     // 使用fmt库格式化字符串
12.     std::string message = fmt::format("Formatted number: {}", 42);
13.     std::cout << message << std::endl;
14.    
15.     // 使用自定义库
16.     MyLib lib;
17.     lib.doSomething();
18.    
19.     return 0;
20. }

复制代码

构建这个复杂项目的步骤与前面的示例类似，但需要先安装fmt库。可以使用vcpkg或其他包管理器来安装fmt：

2. # 使用vcpkg安装fmt
3. vcpkg install fmt

复制代码

然后，在生成NMake makefile时，需要指定vcpkg的工具链文件：

2. cmake -G "NMake Makefiles" -DCMAKE_TOOLCHAIN_FILE=[vcpkg root]/scripts/buildsystems/vcpkg.cmake ..
3. nmake

复制代码

最佳实践

在使用CMake和NMake进行跨平台项目构建时，以下是一些最佳实践建议：

项目结构组织

• 使用清晰的目录结构，将源文件、头文件、库文件等分别放在不同的目录中
• 为每个子项目创建单独的CMakeLists.txt文件
• 使用统一的命名约定，便于维护和理解

CMakeLists.txt编写技巧

• 使用变量和宏来减少重复代码
• 使用option命令定义构建选项，增加灵活性
• 使用find_package查找外部依赖，而不是硬编码路径
• 使用target_include_directories和target_link_libraries等现代CMake命令，而不是全局命令
• 为不同的构建类型（Debug、Release等）设置不同的编译选项

NMake使用技巧

• 使用宏定义来简化makefile的编写
• 使用条件判断和循环来处理复杂的构建逻辑
• 使用依赖关系来确保构建顺序正确
• 使用nmake /D显示依赖关系，帮助调试构建问题

跨平台构建策略

• 使用CMake的条件判断来处理平台特定的代码和设置
• 为不同的平台和编译器设置不同的编译选项
• 使用CMake的生成器表达式来处理平台差异
• 在CI/CD系统中使用矩阵构建，确保项目在所有目标平台上都能正常构建

性能优化

• 使用CMake的CMAKE_BUILD_TYPE来控制优化级别
• 使用NMake的并行构建功能（nmake /j<number>）来加速构建
• 使用预编译头文件来减少编译时间
• 使用统一构建（Unity builds）来减少链接时间

总结

CMake和NMake是跨平台项目构建中的黄金搭档。CMake提供了跨平台的抽象层和灵活的构建系统生成能力，而NMake提供了Windows平台上的高效构建能力。通过协同工作，它们可以显著提高跨平台项目的开发效率。

CMake的主要优势在于其跨平台性和灵活性，它可以根据不同的平台生成相应的构建文件。NMake则以其高效的增量构建和强大的依赖管理能力著称，特别适合Windows平台上的大型项目。

在实际开发中，开发者可以使用CMake编写平台无关的构建脚本，然后使用CMake生成NMake的makefile文件，最后使用NMake执行实际的构建工作。这种组合既保证了跨平台的兼容性，又充分利用了Windows平台的构建能力。

通过遵循最佳实践，如合理的项目结构组织、清晰的CMakeLists.txt编写、高效的NMake使用策略等，开发者可以进一步提高构建效率，减少构建错误，加速开发进程。

总之，CMake与NMake的协同工作为跨平台项目构建提供了一个强大而灵活的解决方案，是Windows平台跨开发中不可或缺的工具组合。