cmake的简单使⽤⽰例
CMake ⽤法导览
Preface : 本⽂是CMake官⽅⽂档CMake Tutorial () 的翻译。通过⼀个样例⼯程从简单到复杂的完善过程，⽂档介绍了CMake主要模块（cmake, ctest, cpack）的功能和使⽤环境；从中可以⼀窥cmake的⼤体形貌。正⽂如下：
本⽂下述内容是⼀个⼿把⼿的使⽤指南；它涵盖了CMake需要解决的公共构建系统的⼀些问题。这些主题中的许多主题已经在`Mastering CMake⼀书中以单独的章节被介绍过，但是通过⼀个样例⼯程看⼀看它们如何⼯作也是⾮常有帮助的。本指南可以在CMake源码树的Tests/Tutorial路径下到。每⼀步都有它⾃⼰的⼦路径，其中包含该步骤的⼀个完整的指南。
1.作为基础的起始点（步骤1）
最基本的⼯程是⼀个从源代码⽂件中构建可执⾏⽂件的例⼦。对于简单⼯程，只要⼀个两⾏的CMakeLists⽂件就⾜够了。这将会作为我们指南的起点。这份CMakeLists⽂件看起来像是这样：
1. cmake_minimum_required (VERSION
2.6)
2. project (Tutorial)
3. add_executable()
注意到这个例⼦在CMakeLists⽂件中使⽤了⼩写。CMake⽀持⼤写、⼩写、混合⼤⼩写的命令。中的源代码⽤来计算⼀个数的平⽅根，并且它的第⼀版⾮常简单，如下所⽰：
1. // A simple program that computes the square root of a number
2. // 计算⼀个数的平⽅根的简单程序
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <math.h>
6.
7. int main (int argc, char *argv[]) {
8. if (argc < 2) {
9. fprintf(stdout,"Usage: %s number\n",argv[0]);
10. return 1;
11. }
12. double inputValue = atof(argv[1]);
13. double outputValue = sqrt(inputValue);
14. fprintf(stdout,"The square root of %g is %g\n", inputValue, outputValue);
15. return 0;
16. }
我们添加的第⼀个特性⽤来为⼯程和可执⾏⽂件指定⼀个版本号。虽然你可以在源代码中唯⼀指定它，但是你在CMakeLists⽂件中指定它可以提供更好的灵活性。如下所⽰，我么可以通过添加⼀个版本号来修改CMakeLists⽂件：
1. cmake_minimum_required (VERSION
2.6)
2. project (Tutorial)
3. # 版本号
4. set (Tutorial_VERSION_MAJOR 1)
5. set (Tutorial_VERSION_MINOR 0)
6. # 配置⼀个头⽂件，通过它向源代码中传递⼀些CMake设置。
7. configure_file (
8. "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
9. "${PROJECT_BINARY_DIR}/TutorialConfig.h"
10. )
11. # 将⼆进制⽂件树添加到包含⽂件的搜索路径中，这样我们可以到TutorialConfig.h
12. include_directories("${PROJECT_BINARY_DIR}")
13. # 添加可执⾏⽂件
14. add_executable()
由于配置过的⽂件将会被写到⼆进制⽂件⽬录下，我们必须把该⽬录添加到包含⽂件的搜索路径清单中。然后，以下的代码就可以在源⽬录下创建⼀份TotorialConfig.h.in⽂件：
1. // 与tutorial相关的配置好的选项与设置；
2. #define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
3. #define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
当CMake配置这份头⽂件时，@Tutorial_VERSION_MAJOR@和@Tutorial_VERSION_MINOR@的值将会被从CMakeLists⽂件中传递过来的值替代。下⼀步，我们要修改来包含configured头⽂件然后使⽤其中的版本号。修改过的源代码展列于下：
1. // 计算平⽅根的简单程序。
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5. #include "TutorialConfig.h"
6.
7. int main (int argc, char *argv[]) {
8. if (argc < 2) {
9. fprintf(stdout,"%s Version %d.%d\n",
10. argv[0],
11. Tutorial_VERSION_MAJOR,
12. Tutorial_VERSION_MINOR);
13. fprintf(stdout,"Usage: %s number\n",argv[0]);
14. return 1;
15. }
16. double inputValue = atof(argv[1]);
17. double outputValue = sqrt(inputValue);
18. fprintf(stdout,"The square root of %g is %g\n", inputValue, outputValue);
19. return 0;
}
2.引⼊库（步骤2）
现在我们将会在我们的⼯程中引⼊⼀个库。这个库会包含我们⾃⼰实现的计算⼀个数的平⽅根的函数。可执⾏⽂件随后可以使⽤这个库⽂件⽽不是编译器提供的标准开平⽅函数。在本指南中，我们将会把库⽂件放到⼀个⼦⽬录MathFunctions中。它包含下述的单⾏CMakeLists⽂件：
1. add_library()
源⽂件有⼀个叫做mysqrt的函数，它提供了与编译器的sqrt函数类似的功能。为了使⽤新的库，我们在顶层的CMakeLists中增加⼀个add_subdirectory调⽤，这样这个库也会被构建。我们也要向可执⾏⽂件中增加另⼀个头⽂件路径，这样就可以从MathFunctions/mysqrt.h头⽂件中到函数的原型。最后的⼀点更改是在向可执⾏⽂件中引⼊新的库。顶层CMakeLists⽂件的最后⼏⾏现在看起来像是这样：
1. include_directories ("${PROJECT_SOURCE_DIR}/MathFunctions")
2. add_subdirectory (MathFunctions)
3. # 引⼊可执⾏⽂件
4. add_executable ()
5. target_link_libraries (Tutorial MathFunctions)
现在，让我们考虑下让MathFunctions库变为可选的。在本指南中，确实没有必要这样画蛇添⾜；但是对于更⼤型的库或者依赖于第三⽅代码的库，你可能需要这种可选择性。第⼀步是为顶层的CMakeLists⽂件添加⼀个选项：
1. # 我们应该使⽤我们⾃⼰的数学函数吗？
2. option (USE_MYMATH "Use tutorial provided math implementation" ON)
这将会在CMake的GUI中显⽰⼀个默认的ON值，并且⽤户可以随需改变这个设置。这个设置会被存储在cache中，那么⽤户将不需要在cmake该⼯程时，每次都设置这个选项。第⼆处改变是，让链接MathFunctions库变为可选的。要实现这⼀点，我们修改顶层CMakeLists⽂件的结尾部分：
1. # 添加MathFunctions库吗？
2. if (USE_MYMATH)
3. include_directories ("${PROJECT_SOURCE_DIR}/MathFunctions")
4. add_subdirectory (MathFunctions)
5. set (EXTRA_LIBS ${EXTRA_LIBS} MathFunctions)
6. endif (USE_MYMATH)
7. # 添加可执⾏⽂件
8. add_executable ()
9. target_link_libraries (Tutorial ${EXTRA_LIBS})
这⾥⽤USE_MYMATH设置来决定是否MathFunctions应该被编译和执⾏。注意到，要⽤⼀个变量（在这⾥是EXTRA_LIBS）来收集所有以后会被连接到可执⾏⽂件中的可选的库。这是保持带有许多可选部件的较⼤型⼯程⼲净清爽的⼀种通⽤的⽅法。源代码对应的改变相当直⽩，如下所⽰：
1. // 计算⼀个数平⽅根的简单程序
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5. #include "TutorialConfig.h"
6. #ifdef USE_MYMATH
7. #include "MathFunctions.h"
8. #endif
9.
10. int main (int argc, char *argv[]) {
11. if (argc < 2) {
12. fprintf(stdout,"%s Version %d.%d\n", argv[0],
13. Tutorial_VERSION_MAJOR,
14. Tutorial_VERSION_MINOR);
15. fprintf(stdout,"Usage: %s number\n",argv[0]);
16. return 1;
17. }
18.
19. double inputValue = atof(argv[1]);
20.
21. #ifdef USE_MYMATH
22. double outputValue = mysqrt(inputValue);
23. #else
24. double outputValue = sqrt(inputValue);
25. #endif
26.
27. fprintf(stdout,"The square root of %g is %g\n", inputValue, outputValue);
28. return 0;
29. }
在源代码中，我们也使⽤了USE_MYMATH。这个宏是由CMake通过TutorialConfig.h.in配置⽂件中的下述语句⾏提供给源代码的：
1. #cmakedefine USE_MYMATH
3.安装与测试（步骤3）
下⼀步我们会为我们的⼯程引⼊安装规则以及测试⽀持。安装规则相当直⽩，对于MathFunctions库，我们通过向MathFunctions的CMakeLists⽂件添加如下两条语句来设置要安装的库以及头⽂件：
1. install (TARGETS MathFunctions DESTINATION bin)
2. install (FILES MathFunctions.h DESTINATION include)
对于应⽤程序，在顶层CMakeLists⽂件中添加下⾯⼏⾏，它们⽤来安装可执⾏⽂件以及配置头⽂件：
1. # 添加安装⽬标
3. install (FILES "${PROJECT_BINARY_DIR}/TutorialConfig.h" DESTINATION include)
这就是要做的全部；现在你应该可以构建tutorial⼯程了。然后，敲⼊命令make install（或者从IDE中
构建INSTALL⽬标）然后它就会安装需要的头⽂件，库以及可执⾏⽂件CMake的变量CMAKE_INSTALL_PREFIX⽤来确定这些⽂件被安装的根⽬录。添加测试同样也只需要相当浅显的过程。在顶层CMakeLists⽂件的的尾部补充许多基本的测试代码来确认应⽤程序可以正确⼯作。
1. # 应⽤程序是否运⾏?
2. add_test (TutorialRuns Tutorial 25)
3.
4. # 它是否对25做了开平⽅运算
5. add_test (TutorialComp25 Tutorial 25)
6.
7. set_tests_properties (TutorialComp25
8. PROPERTIES PASS_REGULAR_EXPRESSION "25 is 5")
9.
10. # 它是否能处理是负数作为输⼊的情况
11. add_test (TutorialNegative Tutorial -25)
12. set_tests_properties (TutorialNegative
13. PROPERTIES PASS_REGULAR_EXPRESSION "-25 is 0")
14.
15. # 它是否可以处理较⼩的数字。
16. add_test (TutorialSmall Tutorial 0.0001)
17. set_tests_properties (TutorialSmall
18. PROPERTIES PASS_REGULAR_EXPRESSION "0.0001 is 0.01")
19.
20. # ⽤法信息是否可⽤？
21. add_test (TutorialUsage Tutorial)
22. set_tests_properties (TutorialUsage
23. PROPERTIES
24. PASS_REGULAR_EXPRESSION "Usage:.*number")
第⼀个测试⽤例仅仅⽤来验证程序可以运⾏，没有出现段错误或其他的崩溃，并且返回值必须是0。这是CTest所做测试的基本格式。余下的⼏个测试都是⽤
PASS_REGULAR_EXPRESSION 测试属性来验证测试代码的输出是否包含有特定的字符串。在本例中，测试样例⽤来验证计算得出的平⽅根与预定值⼀样；当指定错误的输⼊数据时，要打印⽤法信息。如果你想要添加许多测试不同输⼊值的样例，你应该考虑创建如下所⽰的宏：
1. #定义⼀个宏来简化添加测试的过程，然后使⽤它
2. macro (do_test arg result)
3. add_test (TutorialComp${arg} Tutorial ${arg})
4. set_tests_properties (TutorialComp${arg}
5. PROPERTIES PASS_REGULAR_EXPRESSION ${result})
6. endmacro (do_test)
7. # 做⼀系列基于结果的测试
8. do_test (25 "25 is 5")
9. do_test (-25 "-25 is 0")
对于每个do_test宏调⽤，都会向⼯程中添加⼀个新的测试⽤例；宏参数是测试名、函数的输⼊以及期望结果。
4.增加系统内省（步骤4）
下⼀步，让我们考虑向我们的⼯程中引⼊⼀些依赖于⽬标平台上可能不具备的特性的代码。在本例中，我们会增加⼀些依赖于⽬标平台是否有log或exp函数的代码。当然，⼏乎每个平台都有这些函数；但是对于tutorial⼯程，我们假设它们并⾮如此普遍。如果该平台有log函数，那么我们会在mysqrt
函数中使⽤它去计算平⽅根。我们⾸先在顶层CMakeLists⽂件中使⽤宏ake测试这些函数的可⽤性：
1. # 该系统提供log和exp函数吗？
2. include (ake)
3. check_function_exists (log HAVE_LOG)
4. check_function_exists (exp HAVE_EXP)
下⼀步，如果CMake在对应平台上到了它们，我们修改TutorialConfig.h.in来定义这些值；如下：
1. // 该平台提供exp和log函数吗？
2. #cmakedefine HAVE_LOG
3. #cmakedefine HAVE_EXP
这些log和exp函数的测试要在TutorialConfig.h的configure_file命令之前被处理，这⼀点很重要。最后，在mysqrt函数中，如果log和exp在当前系统上可⽤的话，我们可以提供⼀个基于它们的可选的实
现：
1. // 如果我们有log和exp两个函数，那么使⽤它们
2. #if defined (HAVE_LOG) && defined (HAVE_EXP)
3. result = exp(log(x)*0.5);
4. #else // 否则使⽤替代⽅法
5.添加⼀个⽣成⽂件以及⽣成器（步骤5）
在本节，我们会展⽰你应该怎样向⼀个应⽤程序的构建过程中添加⼀个⽣成的源⽂件。在本范例中，我们会创建⼀个预先计算出的平⽅根表作为构建过程的⼀部分。MathFunctions⼦路径下，⼀个新的源⽂件来做这件事。
1. // ⼀个简单的⽤于构建平⽅根表的程序
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5.
6. int main (int argc, char *argv[]) {
7. int i;
8. double result;
9.
10. // 确保有⾜够多的参数
12. return 1;
13. }
14.
15. // 打开输出⽂件
16. FILE *fout = fopen(argv[1],"w");
17. if (!fout) {
18. return 1;
19. }
20.
21. // 创建⼀个带有平⽅根表的源⽂件
22. fprintf(fout,"double sqrtTable[] = {\n");
23. for (i = 0; i < 10; ++i) {
24. result = sqrt(static_cast<double>(i));
25. fprintf(fout,"%g,\n",result);
26. }
27.
28. // 该表以0结尾
29. fprintf(fout,"0};\n");
30. fclose(fout);
31. return 0;
32. }
注意到这个表是由合法的C++代码⽣成的，并且被写⼊的输出⽂件的名字是作为⼀个参数输⼊的。下⼀步是将合适的命令添加到MathFunction的CMakeLists⽂件中，来构建MakeTable可执⾏⽂件，然后运⾏它，作为构建过程的⼀部分。完成这⼏步，需要少数的⼏个命令，如下所⽰：
1. # ⾸先，我们添加⽣成该表的可执⾏⽂件
2. add_executable()
3. # 然后添加该命令来⽣成源⽂件
4. add_custom_command (
5. OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Table.h
6. COMMAND MakeTable ${CMAKE_CURRENT_BINARY_DIR}/Table.h
7. DEPENDS MakeTable
8. )
9.
10. # 为包含⽂件，向搜索路径中添加⼆进制树路径
11. include_directories( ${CMAKE_CURRENT_BINARY_DIR} )
12.
13. # 添加main库
14. add_library( ${CMAKE_CURRENT_BINARY_DIR}/Table.h )
⾸先，MakeTable的可执⾏⽂件也和其他被加⼊的⽂件⼀样被加⼊。然后，我们添加⼀个⾃定义命令来指定如何通过运⾏MakeTable来⽣成Table.h。这是通过将⽣成Table.h增加到MathFunctions库的源⽂件列表中来实现的。我们还必须增加当前的⼆进制路径到包含路径的清单中，这样Table.h可以被到并且可以被所包含。当该⼯程被构建后，它⾸先会构建MakeTable可执⾏⽂件。然后它会运⾏MakeTable来⽣成Table.h⽂件。最后，它会编译（其中包含Table.h）来⽣成MathFunctions库。到⽬前为⽌，拥有我们添加的完整特性的顶层CMakeLists⽂件看起来像是这样：
1. cmake_minimum_required (VERSION
2.6)
2. project (Tutorial)
3.
4. # 版本号
5. set (Tutorial_VERSION_MAJOR 1)
6. set (Tutorial_VERSION_MINOR 0)
7.
8. # 本系统是否提供log和exp函数?
9. include (${CMAKE_ROOT}/ake)
10.
11. check_function_exists (log HAVE_LOG)
12. check_function_exists (exp HAVE_EXP)
13.
14. # 我们应该使⽤⾃⼰的math函数吗?
15. option(USE_MYMATH
16. "Use tutorial provided math implementation" ON)
17.
18. # 配置⼀个头⽂件来向源代码传递⼀些CMake设置。
19. configure_file (
20. "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
21. "${PROJECT_BINARY_DIR}/TutorialConfig.h"
22. )
23.
24. # 为包含⽂件的搜索路径添加⼆进制树，这样才能发现TutorialConfig.h头⽂件。
25. include_directories ("${PROJECT_BINARY_DIR}")
26.
27. # 添加MathFunctions库吗?
28. if (USE_MYMATH)
29. include_directories ("${PROJECT_SOURCE_DIR}/MathFunctions")
30. add_subdirectory (MathFunctions)
31. set (EXTRA_LIBS ${EXTRA_LIBS} MathFunctions)
32. endif (USE_MYMATH)
33.
34. # 添加可执⾏⽂件
35. add_executable ()
36. target_link_libraries (Tutorial ${EXTRA_LIBS})
37.
38. # 添加安装的⽬标
39. install (TARGETS Tutorial DESTINATION bin)
40. install (FILES "${PROJECT_BINARY_DIR}/TutorialConfig.h"
41. DESTINATION include)
42.
43. # 测试1 ：应⽤程序可以运⾏吗?
44. add_test (TutorialRuns Tutorial 25)
45.
46. # 测试2 ：使⽤信息可⽤吗?
47. add_test (TutorialUsage Tutorial)
48. set_tests_properties (TutorialUsage
49. PROPERTIES
50. PASS_REGULAR_EXPRESSION "Usage:.*number"
51. )
53. # 定义⼀个可以简化引⼊测试过程的宏
54. macro (do_test arg result)
55. add_test (TutorialComp${arg} Tutorial ${arg})
56. set_tests_properties (TutorialComp${arg}
57. PROPERTIES PASS_REGULAR_EXPRESSION ${result}
58. )
59. endmacro (do_test)
60.
61. # do a bunch of result based tests
62. # 执⾏⼀系列基于结果的测试
63. do_test (4 "4 is 2")
64. do_test (9 "9 is 3")
fprintf格式
65. do_test (5 "5 is 2.236")
66. do_test (7 "7 is 2.645")
67. do_test (25 "25 is 5")
68. do_test (-25 "-25 is 0")
69. do_test (0.0001 "0.0001 is 0.01")
TutorialConfig.h⽂件看起来像是这样：
1. // Tutorial的配置选项与设置如下
2. #define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
3. #define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
4. #cmakedefine USE_MYMATH
5.
6. // 该平台提供exp和log函数吗?
7. #cmakedefine HAVE_LOG
8. #cmakedefine HAVE_EXP
然后，MathFunctions⼯程的CMakeLists⽂件看起来像是这样：
1. # ⾸先，我们添加⽣成这个表的可执⾏⽂件
2. add_executable()
3. # 添加⽣成源代码的命令
4. add_custom_command (
5. OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Table.h
6. DEPENDS MakeTable
7. COMMAND MakeTable ${CMAKE_CURRENT_BINARY_DIR}/Table.h
8. )
9. # 为包含⽂件向搜索路径中添加⼆进制树⽬录
10. include_directories( ${CMAKE_CURRENT_BINARY_DIR} )
11.
12. # 添加main库
13. add_library( ${CMAKE_CURRENT_BINARY_DIR}/Table.h)
14. install (TARGETS MathFunctions DESTINATION bin)
15. install (FILES MathFunctions.h DESTINATION include)
6.构建⼀个安装器（步骤6）
下⼀步假设我们想要向其他⼈分发我们的⼯程，这样他们就可以使⽤它。我们想同时提供在许多不同平台上的源代码和⼆进制⽂档发⾏版。这与之前我们在“安装与测试（步骤3）”做过的安装有⼀点不同，那⾥我们仅仅安装我们从源码中构建出来的⼆进制⽂件。在本例⼦中，我们会构建⽀持⼆进制安装以及类似于cygwin，debian，RPM等具有包管理特性的安装包。为了完成这个⽬标，我们会使⽤CPack来创建Packaging with CPack⼀章中描述的特定平台的安装器。
1. # 构建⼀个CPack驱动的安装包
2. include (InstallRequiredSystemLibraries)
3. set (CPACK_RESOURCE_FILE_LICENSE
4. "${CMAKE_CURRENT_SOURCE_DIR}/")
5. set (CPACK_PACKAGE_VERSION_MAJOR "${Tutorial_VERSION_MAJOR}")
6. set (CPACK_PACKAGE_VERSION_MINOR "${Tutorial_VERSION_MINOR}")
7. include (CPack)
需要做的全部事情就这些。我们以包含InstallRequiredSystemLibraries开始。这个模块将会包含许多在当前平台上，当前⼯程需要的运⾏时库。第⼀步我们将⼀些CPack变量设置为保存本⼯程的许可证和版本信息的位置。版本信息使⽤了我们在本指南中先前设置的变量。最后，我们要包含CPack模块，它会使⽤这些变量以及你所处的系统的⼀些别的属性，然后来设置⼀个安装器。下⼀步是以通常的⽅式构建该⼯程然后随后运⾏CPack。如果要构建⼀个⼆进制发⾏包，你应该运⾏：
1. cpack -ake
为了创建⼀个源代码发⾏版，你应该键⼊：
1. cpack -ake
7.增加对Dashboard的⽀持（步骤7）
增加对向⼀个dashboard提交我们的测试结果的功能的⽀持⾮常简单。我们在本指南的先前步骤中已经定义了我们⼯程中的许多测试样例。我们仅仅需要运⾏这些测试样例然后将它们提交到dashboard即可。为了包含对dashboards的⽀持，我们需要在顶层CMakeLists⽂件中包含CTest模块。
1. # ⽀持dashboard脚本
2. include (CTest)
我们也可以创建⼀个ake⽂件，在其中来指定该dashboard的⼯程名。
1. set (CTEST_PROJECT_NAME "Tutorial")
CTest 将会在运⾏期间读取这个⽂件。为了创建⼀个简单的dashboard，你可以在你的⼯程下运⾏CMake，然后切换到⼆进制树，然后运⾏ctest -DExperimental. 你的dashboard 将会被更新到Kitware的公共dashboard.

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。