CMake之初级教程

合集下载

超详细的cmake入门教程

超详细的cmake⼊门教程什么是cmake你或许听过好⼏种 Make ⼯具，例如 GNU Make ，QT 的 qmake ，微软的 MSnmake，BSD Make（pmake），Makepp，等等。

这些 Make ⼯具遵循着不同的规范和标准，所执⾏的 Makefile 格式也千差万别。

这样就带来了⼀个严峻的问题：如果软件想跨平台，必须要保证能够在不同平台编译。

⽽如果使⽤上⾯的 Make ⼯具，就得为每⼀种标准写⼀次 Makefile ，这将是⼀件让⼈抓狂的⼯作。

CMake CMake附图 1 CMake就是针对上⾯问题所设计的⼯具：它⾸先允许开发者编写⼀种平台⽆关的 CMakeList.txt ⽂件来定制整个编译流程，然后再根据⽬标⽤户的平台进⼀步⽣成所需的本地化 Makefile 和⼯程⽂件，如 Unix 的 Makefile 或Windows 的 Visual Studio ⼯程。

从⽽做到“Write once, run everywhere”。

显然，CMake 是⼀个⽐上述⼏种 make 更⾼级的编译配置⼯具。

⼀些使⽤ CMake 作为项⽬架构系统的知名开源项⽬有 VTK、ITK、KDE、OpenCV、OSG 等。

在 linux 平台下使⽤ CMake ⽣成 Makefile 并编译的流程如下：1. 编写 CMake 配置⽂件 CMakeLists.txt 。

2. 执⾏命令 cmake PATH 或者 ccmake PATH ⽣成 Makefile。

其中， PATH 是 CMakeLists.txt 所在的⽬录。

（ccmake 和cmake 的区别在于前者提供了⼀个交互式的界⾯）3. 使⽤ make 命令进⾏编译。

⼊门案例：单个源⽂件本节对应的源代码所在⽬录：Demo1。

对于简单的项⽬，只需要写⼏⾏代码就可以了。

例如，假设现在我们的项⽬中只有⼀个源⽂件，该程序的⽤途是计算⼀个数的指数幂。

Cmake手册详解

目录一、CMake2.8.3 选项 (5)用法 (6)描述 (6)选项 (6)生成器 (13)二、CMake命令 (16)CMD#1 : add_custom_command (17)CMD#2: add_custom_target (19)CMD#3:add_definitions (20)CMD#4:add_dependencies (21)CMD#5:add_executable: (21)CMD#6:add_library (22)CMD#7:add_subdirectory (23)CMD#8:add_test (24)CMD#9:aux_source_directory (25)CMD#10:break (26)CMD#11:build_command (26)CMD#12:cmake_minimum_required (27)CMD#13:cmake_policy (27)CMD#14:configure_file: (29)CMD#15:create_test_sourcelist: (30)CMD#16:define_property: (30)CMD#17: else (31)CMD#18: elseif (31)CMD#19: enable_language (32)CMD#20: enable_testing (32)CMD#21: endforeach (32)CMD#22: endfunction (32)CMD#23: endif (32)CMD#24: endmacro (33)CMD#25: endwhile (33)CMD#26: execute_process (33)CMD#27:export (34)CMD#28: file (35)CMD#29:find_file (38)CMD#30:find_library (42)CMD#31:find_package (45)CMD#32 : find_path (52)CMD#33:find_program (55)CMD#34:fltk_wrap_ui (59)CMD#35 : foreach (59)CMD#36 : function (60)CMD#37 : get_cmake_property (61)CMD#38 : get_directory_property (61)CMD#39 : get_filename_component (61)CMD#40 : get_property (62)CMD#42 : get_target_property (63)CMD#43 : get_test_property (64)CMD#44 : if (64)CMD#45 : include (69)CMD#46 : include_directories (69)CMD#47 : include_external_msproject (70)CMD#48 : include_regular_expression (70)CMD#49 : install (70)CMD#50 : link_directories 指定连接器查找库的路径。

AndroidStudio用Cmake方式编译NDK代码（cmake配置.a库）

AndroidStudio⽤Cmake⽅式编译NDK代码（cmake配置.a库）1.cmake是什么？CMake是⼀个跨平台的安装（）⼯具，可以⽤简单的语句来描述所有平台的安装(编译过程)。

他能够输出各种各样的makefile或者project⽂件，能测试所⽀持的C++特性,类似UNIX下的automake。

⾕歌从AndroidStudio2.2以上就添加了Cmake⽅式来编译NDK代码，并从NDK例⼦看出，默认编译的⽅式就是cmake⽅式。

2.⾕歌官⽅的⽤cmake⽅式编译NDK的教程⾕歌从AndroidStudio2.2以上就添加了Cmake⽅式来编译NDK代码，并从NDK例⼦看出，默认编译的⽅式就是cmake⽅式。

如果您希望向现有项⽬添加原⽣代码，请执⾏以下步骤：1. 并将其添加到您的 Android Studio 项⽬中。

如果您已经拥有原⽣代码或想要导⼊预构建的原⽣库，则可以跳过此步骤。

2. ，将您的原⽣源代码构建到库中。

如果导⼊和关联预构建库或平台库，您也需要此构建脚本。

如果您的现有原⽣库已经拥有CMakeLists.txt构建脚本或者使⽤ ndk-build 并包含构建脚本，则可以跳过此步骤。

3. 提供⼀个指向您的 CMake 或 ndk-build 脚本⽂件的路径，。

Gradle 使⽤构建脚本将源代码导⼊您的 Android Studio 项⽬并将原⽣库（SO ⽂件）封装到 APK 中。

配置完项⽬后，您可以使⽤从 Java 代码中访问您的原⽣函数。

要构建和运⾏应⽤，只需点击 Run 。

Gradle 会以依赖项的形式添加您的外部原⽣构建流程，⽤于编译、构建原⽣库并将其随 APK ⼀起封装。

创建新的原⽣源⽂件要在应⽤模块的主源代码集中创建⼀个包含新建原⽣源⽂件的cpp/⽬录，请按以下步骤操作：1. 从 IDE 的左侧打开 Project 窗格并从下拉菜单中选择 Project 视图。

2. 导航到您的模块 > src，右键点击 main ⽬录，然后选择 New > Directory。

CMAKE使用教程(英文)

Autotools cons
• Complete tool chain of several programs, each with different "macro" syntax (quotes)
(autcoconf, automake, libtool, m4, sh, make) • Creates big build scripts and helper files even for a hello world example
CMake pros
• More usefull error messages when making a mistake in editing input files • Easy to use configure-like framework • CMake has simple syntax • CMake has a testing framework • CMake is faster than autotools (does not use libtools)
CMake
• Comparison between cmake and autotools • Using cmake • Definition and usage of tests • Quality Dashboard • Automatic testing
Autotools pro
• State of the art on *ix systems • Easy to use for users (./configure && make &&make inst_cbmroot export SIMPATH=<PATH_TO_EXTERN> (Not even needed at GSI)

linux_cmake学习指导

在 linux 下使用 CMake 构建应用程序级别：初级王程明 (wangchengming.jlu@), 硕士研究生, 吉林大学计算机科学与技术学院2009 年 2 月 05 日本文介绍了一个跨平台的自动化构建系统 CMake 在 linux 上的使用方法。

CMake 是一个比automake 更加容易使用的工具，能够使程序员从复杂的编译连接过程中解脱出来。

文中通过一些例子介绍使用 CMake 处理多源文件目录的方法、查找并使用其他开发包的方法以及生成 debug 版和 release 版程序的方法。

CMake 简介CMake 是一个跨平台的自动化建构系统,它使用一个名为 CMakeLists.txt 的文件来描述构建过程,可以产生标准的构建文件,如 Unix 的 Makefile 或Windows Visual C++ 的 projects/workspaces 。

文件 CMakeLists.txt 需要手工编写,也可以通过编写脚本进行半自动的生成。

CMake 提供了比autoconfig 更简洁的语法。

在 linux 平台下使用 CMake 生成 Makefile 并编译的流程如下:1.编写 CmakeLists.txt。

2.执行命令 “cmake PATH” 或者 “ccmake PATH” 生成 Makefile ( PATH 是 CMakeLists.txt 所在的目录 )。

3.使用 make 命令进行编译。

第一个工程现假设我们的项目中只有一个源文件 main.cpp清单 1 源文件 main.cpp1 #include<iostream>23 int main()4 {5 std::cout<<"Hello word!"<<std::endl;6 return 0;7 }为了构建该项目,我们需要编写文件 CMakeLists.txt 并将其与 main.cpp 放在同一个目录下:清单 2 CMakeLists.txt1 PROJECT(main)2 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)3 AUX_SOURCE_DIRECTORY(. DIR_SRCS)4 ADD_EXECUTABLE(main ${DIR_SRCS})CMakeLists.txt 的语法比较简单,由命令、注释和空格组成,其中命令是不区分大小写的,符号"#"后面的内容被认为是注释。

CMake基础第10节使用ninja构建

CMake基础第10节使⽤ninja构建介绍如前所述，CMake是⼀个元（meta）构建系统，可⽤于为许多其他构建⼯具创建构建⽂件。

这个例⼦展⽰了如何让CMake使⽤ninja构建⼯具。

本教程中的⽂件如下：$ tree.├── CMakeLists.txt├── main.cpp[CMakeLists.txt] - 包含要运⾏的CMake命令# Set the minimum version of CMake that can be used# To find the cmake version run# $ cmake --versioncmake_minimum_required(VERSION 3.5)# Set the project nameproject (hello_cmake)# Add an executableadd_executable(hello_cmake main.cpp)[main.cpp] - ⼀个简单的“Hello World”CPP⽂件#include <iostream>int main(int argc, char *argv[]){std::cout << "Hello CMake!" << std::endl;return 0;}概念⽣成器CMake⽣成器负责为底层构建系统编写输⼊⽂件(例如Makefile)。

运⾏cmake--help将显⽰可⽤的⽣成器。

对于cmake v2.8.12.2，我的系统⽀持的⽣成器包括：GeneratorsThe following generators are available on this platform:Unix Makefiles = Generates standard UNIX makefiles.Ninja = Generates build.ninja files (experimental).CodeBlocks - Ninja = Generates CodeBlocks project files.CodeBlocks - Unix Makefiles = Generates CodeBlocks project files.Eclipse CDT4 - Ninja = Generates Eclipse CDT 4.0 project files.Eclipse CDT4 - Unix Makefiles= Generates Eclipse CDT 4.0 project files.KDevelop3 = Generates KDevelop 3 project files.KDevelop3 - Unix Makefiles = Generates KDevelop 3 project files.Sublime Text 2 - Ninja = Generates Sublime Text 2 project files.Sublime Text 2 - Unix Makefiles= Generates Sublime Text 2 project files.Generators正如本⽂所述，CMake包括不同类型的⽣成器，如命令⾏⽣成器、IDE⽣成器和其他⽣成器。

Cmake使用教程-交叉编译

Cmake使⽤教程-交叉编译Cmake Cross Compile UserGuide1. 设置系统和⼯具链对于交叉编译，CMake并不知道⽬标系统是什么，所以需要设置⼀些CMake变量来告知CMake，CMAKE_SYSTEM_NAME：即⽬标系统名，这⾥是LinuxCMAKE_SYSTEM_PROCESSOR ：⽬标系统的处理器名，这⾥是arm对于⼯具链，则是通过下⾯2个变量来定位，CMAKE_C_COMPILER：C编译器的可执⾏⽂件名称CMAKE_CXX_COMPILER：C++编译器的可执⾏⽂件名称这些变量可以在调⽤CMake时通过命令⾏传递，但是这种做法容易出错，⽽且⽤起来不⽅便，所以CMake提供了⼯具链⽂件的⽅式来传递这些变量信息。

2. ⼯具链⽂件我们在⼯程⾥新建⼀个⽂件叫arm_linux_setup.cmake，放置位置如下（也可以放在别的地⽅），set(CMAKE_SYSTEM_NAME Linux)set(CMAKE_SYSTEM_PROCESSOR arm)set(tools /home/wh/work/cross_compile/gcc-linaro-7.3.1-2018.05-x86_64_arm-linux-gnueabihf)set(CMAKE_C_COMPILER ${tools}/bin/arm-linux-gnueabihf-gcc)set(CMAKE_CXX_COMPILER ${tools}/bin/arm-linux-gnueabihf-g++)注意：上述命令必须写⼊脚本中，使⽤ -DCMAKE_TOOLCHAIN_FILE=xxx.cmake 的⽅式使⽤。

不能直接写⼊ CMakeLists.txt 或使⽤include(xx.cmake) 。

set(CMAKE_SYSTEM_NAME Linux)：该指令必须存在，其⽬的是设置⽬标机使⽤的操作系统名称，⽀持Linux，QNX，WindowsCE，Android等。

CMake词法和语法

词法和语法在开始本节的学习之前，我们先总结一下之前所了解到的CMake基本词法和命令。

CMake命令通常使用如下的格式：1. COMMAND( ARG1 ARG2 … )复制代码命令关键字之后使用括号来包含所有的参数；各个参数之间使用空格或者换行符分隔；而参数通常有以下几种形式：变量，以${MY_VAIRABLE}的形式表达，其储存类型为字符串类型，但是可以根据具体命令的要求自动转换为布尔型、整型或者浮点类型。

变量可以出现在字符串中，也可以实现“内省”。

变量有用户自定义和系统内置两种，用户自定义变量使用SET命令设置；而系统变量由系统自动赋值，例如${PROJECT_SOURCE_DIR}。

枚举量，例如ADD_LIBRARY可以设置要生成的链接库为SHARED或者STATIC，还可以设置为MODULE（插件，可动态调用，但不作为其他工程的依赖），除此之外的赋值都是不能被识别的。

值，也就是任意的字符串内容，它可以用来指示要编译的源代码文件名，也可以表达一段文字提示信息，或者表达特定的功能。

值可以使用引号进行标识，多数情况下也可以不用。

前文中我们已经了解到的命令列举如下，此外这里还简要地介绍了另一些可能在各类CMake 工程中遇到的命令及其语法格式。

CMake部分命令的语法歌是十分复杂，这里仅仅介绍它的某一种实现形式，建议读者阅读CMake的帮助文档以获取更多信息。

括号中为该命令的一个或多个参数项，其中使用“[…]”包含的项表示可忽略项，使用“…|…”分隔的项表示只能选择其中一项。

ADD_CUSTOM_COMMAND(TARGET namePRE_BUILD|PRE_LINK|POST_BUILDCOMMAND cmd1 [COMMAND cmd2 …] )：为目标工程name添加一个或多个新的自定义的编译规则cmd1，cmd2等，执行时机可以选择编译前，链接前或者编译后。

它的作用相当于Visual Studio工程的“Custom Build Step”属性。

cmake使用方法详解

cmake使⽤⽅法详解cmake 简介CMake是⼀个跨平台的安装(编译)⼯具,可以⽤简单的语句来描述所有平台的安装(编译过程)。

他能够输出各种各样的makefile或者project ⽂件,能编译器所⽀持的C++特性,类似UNIX下的automake。

CMake 使⽤⽅法CMake的所有的语句都写在⼀个叫:CMakeLists.txt的⽂件中。

当CMakeLists.txt⽂件确定后,可以⽤ccmake命令对相关的变量值进⾏配置。

这个命令必须指向CMakeLists.txt所在的⽬录。

配置完成之后,应⽤cmake命令⽣成相应的makefile（在Unix like系统下）或者 project⽂件（指定⽤window下的相应编程⼯具编译时）。

其基本操作流程为：1. $> ccmake directory2. $> cmake directory3. $> make其中directory为CMakeList.txt所在⽬录；第⼀条语句⽤于配置编译选项，如VTK_DIR⽬录，⼀般这⼀步不需要配置，直接执⾏第⼆条语句即可，但当出现错误时，这⾥就需要认为配置了，这⼀步才真正派上⽤场；第⼆条命令⽤于根据CMakeLists.txt⽣成Makefile⽂件；第三条命令⽤于执⾏Makefile⽂件，编译程序，⽣成可执⾏⽂件；CMake的执⾏就是这么简单，其难点在于如何编写CMakeLists.txt⽂件，下⾯结合例⼦简单介绍CMakeLists.txt的编写，看下⾯这个CMakeLists.txt1. #project name2. PROJECT(test_math)3. #head file path4. INCLUDE_DIRECTORIES(5. include6. )7. #source directory8. AUX_SOURCE_DIRECTORY(src DIR_SRCS)9. #set environment variable10. SET(TEST_MATH11. ${DIR_SRCS}12. )13. #set extern libraries14. SET(LIBRARIES15. libm.so16. )17. #add executable file18. ADD_EXECUTABLE(../bin/bin ${TEST_MATH})19. #add link library20. TARGET_LINK_LIBRARIES(../bin/bin ${LIBRARIES})21.或者⽤下⾯这个CMakeLists.txt[cpp]1. #project name2. PROJECT(test_math)3.4. add_definitions("-Wall -lpthread -g")5.6. #head file path7. INCLUDE_DIRECTORIES(8. include9. )10.11. #source directory12. AUX_SOURCE_DIRECTORY(src DIR_SRCS)13.14. #set environment variable15. SET(TEST_MATH16. ${DIR_SRCS}17. )18.19. #set extern libraries20. SET(LIBRARIES21. libm.so22. )23.24. # set output binary path25. SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)26.27. SET(FS_BUILD_BINARY_PREFIX "Yfs")28.29. #add executable file30. ADD_EXECUTABLE(${FS_BUILD_BINARY_PREFIX}sqrt ${TEST_MATH})31.32. #add link library33. TARGET_LINK_LIBRARIES(${FS_BUILD_BINARY_PREFIX}sqrt ${LIBRARIES})这是⼀个测试数学函数的程序的CMakeLists.txt，"#"后⾯为注释的内容，CMake的命令全部为⼤写第2⾏指定⽣成的⼯程名为test_math第4⾏指定头⽂件⽬录为include第8⾏指定源⽂件⽬录为src，并将其赋值给环境变量DIR_SRCS第10⾏设定环境变量TEST_MATH的值为环境变量DIR_SRCS的值，此处⽤于显⽰如何⽤环境变量对环境变量进⾏赋值第14⾏将数学函数库赋值给环境变量LIBRARIES，当然，可以不⽤这个环境变量，⽽在后⾯直接使⽤该库名第18⾏⽤于指定⽣成⽂件，将环境变量TEST_MATH⽬录下的所有⽂件编译⽣成../bin⽬录下的可执⾏⽂件bin第20⾏指定../bin/bin执⾏时的链接库为环境变量LIBRARIES的值－libm.so下⾯给出源⽂件/src/main.c:1. #include<stdio.h>2. #include"../include/a.h"3. int main()4. {5. double b=25.0;6. double a=0.0;7. a=get_sqrt(b);8.9. ("a is %lf, b is %lf\n",a,b);10. return 0;11. }12./src/a.c1. #include"../include/a.h"2. double get_sqrt(double var1)3. {4. return sqrt(var1);5. }6./include/a.h#ifndef A_FILE_HEADER_INC1.2. #define A_FILE_HEADER_INC3. #include<math.h>4.5. double get_sqrt(double var1);6.7. #endif将CMakeLists.txt放在当前⽬录下，执⾏CMakeLists.txt1. $> cmake .2. $> make即可⽣成可执⾏⽂件，在⽬录/bin下的bin⽂件，好了运⾏看其效果是否和所想⼀样。

cmake指令详解

cmake指令详解所需⽂件名：CmakeLists.txt,在需要操作的每个⽬录下都需要PROJECT(⼯程名字)这条指令会⾃动创建两个变量：<projectname>_BINARY_DIR(⼆进制⽂件保存路径) <projectname>_SOURCE_DIR（源代码路径）cmake系统也帮助我们预定义了PROJECT_BINARY_DIR和PROJECT_SOURCE_DIR其值与上述对应相等SET(变量名变量值)SET(VAR [VALUE] [CACHE TYPEDOCSTRING [FORCE]])SET(SRC_LIST main.c t1.ct2.c)SET(SRC_LIST main.c)MESSAGEMESSAGE([SEND_ERROR | STATUS | FATAL_ERROR] “message to display” …)向终端输出⽤户定义的信息或变量的值SEND_ERROR, 产⽣错误,⽣成过程被跳过STATUS, 输出前缀为—的信息FATAL_ERROR, ⽴即终⽌所有cmake过程ADD_EXECUTABLEADD_EXECUTABLE(可执⾏⽂件名⽣成该可执⾏⽂件的源⽂件)说明源⽂件需要编译出的可执⾏⽂件名例：ADD_EXECUTABLE(hello ${SRC_LIST})说明SRC_LIST变量中的源⽂件需要编译出名为hello的可执⾏⽂件ADD_SUBDIRECTORYADD_SUBDIRECTORY(src_dir [binary_dir] [EXCLUDE_FROM_ALL])向当前⼯程添加存放源⽂件的⼦⽬录，并可以指定中间⼆进制和⽬标⼆进制的存放位置EXCLUDE_FROM_ALL含义：将这个⽬录从编译过程中排除SET(EXECUTABLE_OUTPUT_PATH${PROJECT_BINARY_DIR}/bin)更改⽣成的可执⾏⽂件路径SET(LIBRARY_OUTPUT_PATH${PROJECT_BINARY_DIR}/lib)更改⽣成的库⽂件路径ADD_LIBRARYADD_LIBRARY(libname [SHARED|STATIC|MODULE] [EXCLUDE_FROM_ALL] source1 source2 ... sourceN)⽣成动态静态库例：ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})SET_TARGET_PROPERTIES设置⽬标的⼀些属性来改变它们构建的⽅式。

一步一步学CMake之生成动态库和静态库

⼀步⼀步学CMake之⽣成动态库和静态库⽬录1. 准备源⽂件包含：1.CMakeLists.txt2.Message.cpp3.Message.hpp4.hello-world.cpp详见：2. 创建⽬标库⽂件这次我们要将　Message.cpp　和　Message.hpp　这两个⽂件编译成⼀个静态库⽂件，⽽不是可执⾏⽂件，更改CMakeLists.txt⽂件，创建⼀个新的⽬标⽂件：1.add_library(message2. STATIC3. Message.hpp4. Message.cpp5.)该命令会⽣成构建⼯具指令，⽤于将指定的源⽂件编译为库⽂件，第⼀个参数 message 是将要⽣成的库⽂件的名字，该库名可以在整个CMakeLists.txt中使⽤，⽽实际⽣成的库⽂件名字则会包含前缀(lib)和后缀，后缀取决于第⼆个参数是STATIC还是SHARED，还取决于操作系统。

命令详解见：3. 链接库⽂件告诉CMake必须把库⽂件链接到可执⾏⽂件⾥target_link_libraries(hello-world message)该命令是将库⽂件链接到可执⾏⽂件⾥，这条命令能保证ｈｅｌｌｏ－ｗｏｒｌｄ可执⾏⽂件能够正确地⼀来于　ｍｅｓｓａｇｅ库⽂件（库⽂件总是在可执⾏⽂件之前构建的）。

4. 静态库和共享库下⾯命令中第⼆个参数ＳＴＡＴＩＣ是指⽣成静态库，如果要⽣成共享库，可以直接将其替换为ＳＨＡＲＥＤ关键词。

1.add_library(message STATIC Message.hpp Message.cpp)2.add_library(message SHARED Message.hpp Message.cpp)这⾥顺便简单提⼀下静态（函数）库和共享（函数）库的区别：静态（函数）库是在程序编译时链接的，其实就是⼀个或多个⽬标⽂件的集合，⽤“.a”作为⽂件的后缀。

共享（函数）库中的函数是在当⼀个可执⾏程序在启动的时候被加载，共享（函数）库⼜叫动态（函数）库，⽂件后缀是.so ，windows上叫动态加载函数库，⽂件后缀是.dll1.# set minimum cmake versioncmake_minimum_required(VERSION 3.5 FATAL_ERROR)3.4.# project name and language5.project(recipe-03 LANGUAGES CXX)6.7.# generate an object library from sources8.add_library(message-objs9.OBJECT10.Message.hpp11.Message.cpp12.)13.14.# this is only needed for older compilers15.# but doesn't hurt either to have it16.set_target_properties(message-objs17.PROPERTIES18.POSITION_INDEPENDENT_CODE 119.)20.21.add_library(message-shared22.SHARED23.$<TARGET_OBJECTS:message-objs>24.)25.set_target_properties(message-shared26.PROPERTIES27.OUTPUT_NAME "message"28.)29.30.add_library(message-static31.STATIC32.$<TARGET_OBJECTS:message-objs>33.)34.set_target_properties(message-static35.PROPERTIESOUTPUT_NAME "message"37.)38.39.add_executable(hello-world hello-world.cpp)40.41.target_link_libraries(hello-world message-static)。

cmakeqmakemakefile动态和静态库教程

cmakeqmakemakefile动态和静态库教程makefileMakefile经典教程(掌握这些⾜够)规则：makefile的基本规则就是:1. target 设定编译的target和各种的依赖⽂件已经如何从⽂件⽣成target的命令target : prerequisites ...commandtarget: 可以是object file，也可以是可执⾏⽂件，也可以是标签labelprerequisites: ⽣成target需要的⽂件或者其它的target; make 命令会检查这些依赖和上⼀次make相⽐是否有了改动，来决定这个target是否要重新更新。

command : 任何的shell命令,command⼀定要⽤Tab键开头。

对于command，GNU的make定义了⼀些隐含的规则，因此有的时候也可以不需要提供command，只提供target和依赖，GNU Make会⾃动调⽤隐含的规则(command)：GNU的make很强⼤，它可以⾃动推导⽂件以及⽂件依赖关系后⾯的命令，于是我们就没必要去在每⼀个[.o]⽂件后都写上类似的命令，因为，我们的make会⾃动识别，并⾃⼰推导命令。

⽐如：a.o : a.c不需要提供command，make会⾃动使⽤gcc来⽣成以上就是最核⼼的makefile的规则。

2. 常⽤的语法(1) \ 反斜杠：换⾏符合a.c \b.c(2) 变量定义objects = a.o b.o c.o在使⽤的时候: $(objects)来调⽤这个变量(3) .PHONY : label.PHONYb表⽰后⾯的是⼀个伪⽬标，、(4) 注释 : #(5) make 命令会在当前⽬录下⾃动找: GNUmakefile, makefile, Makefile⽂件进⾏编译，如果要指定可以使⽤ “ make -f xxx”或者 make --file xxx(6) include : include可以把其他的makefile包括到当前的makefile中。

CMake使用教程

CMake使用教程CMake简介CMake是一个跨平台的、开源的构建工具。

cmake是makefile的上层工具，它们的目的正是为了产生可移植的makefile，并简化自己动手写makefile时的巨大工作量.目前很多开源的项目都可以通过CMake工具来轻松构建工程，例如博客之前分享的openHMD、hidapi、OSVR-Core等等，代码的分享者提供源代码和相应的Cmake配置文件，使用者就可以非常方便的在自己的电脑上构建相应的工程，进行开发和调试。

CMake链接CMake官网CMakeWikiCMake3.7 DocumentCMake教程官方英文教程,黑体部分是本人在操作过程中,觉得需要额外提示的地方,整理翻译如下:第一步：一个简单的起点最简单的工程就是将一些源文件编译为可执行程序。

对于简单工程来说，只需要在CMakeList.txt添加2行内容即可。

这就是我们这个教程的起点，CMakeLists.txt文件内容如下：cmake_minimum_required (VERSION 2.6)project (Tutorial)add_executable(Tutorial tutorial.cxx)注意：CMake文件是不区分大小写的，这个例子中CMakeLists.txt文件中都使用小写字母。

源文件”tutorial.cxx”用来计算一个数的平方根，它的第一个版本非常简单，如下所示：// A simple program that computes the square root of a number#include <stdio.h>#include <stdlib.h>#include <math.h>int main (int argc, char *argv[]){if (argc < 2){fprintf(stdout,"Usage: %s number\n",argv[0]);return 1;}double inputValue = atof(argv[1]);double outputValue = sqrt(inputValue);fprintf(stdout,"The square root of %g is %g\n",inputValue, outputValue);return 0;}添加版本号和配置头文件我们添加的第一个特性就是为我们的可执行程序和工程提供一个版本号.你可以在源代码中写入版本号,然而在CMakeLists.txt中提供(版本号)更灵活.修改CMakeLists.txt增加一个版本号,内容如下：cmake_minimum_required (VERSION 2.6)project (Tutorial)# The version number.set (Tutorial_VERSION_MAJOR 1)set (Tutorial_VERSION_MINOR 0)# configure a header file to pass some of the CMake settings# to the source codeconfigure_file ("${PROJECT_SOURCE_DIR}/TutorialConfig.h.in""${PROJECT_BINARY_DIR}/TutorialConfig.h")# add the binary tree to the search path for include files# so that we will find TutorialConfig.hinclude_directories("${PROJECT_BINARY_DIR}")# add the executableadd_executable(Tutorial tutorial.cxx)因为配置文件将会被写入到二进制树当中，我们需要把这个目录添加到头文件路径当中。

cmake新手入门教程

cmake新⼿⼊门教程linux 环境使⽤ cmake 编译⼤型项⽬1.⼀个简单的实例使⽤ cmake 编译⼤型项⽬⾮常⽅便，做个简单的记录。

建⽴⼀个⽬录 win，这⾥⾯是⼯程⽂件。

win 的⽬录如下：win\-- CMakeLists.txt|-- build.sh|-- libs 外部库|-- src|-- CMakeLists.txt|-- common 公⽤头⽂件|-- win98 win98⼯程| |-- CMakeLists.txt| |-- | |-- win98.h| \-- ||-- win2000 win2000⼯程|-- CMakeLists.txt|-- |-- win2000.h\-- win、src、win98、win2000 四个⽬录下都有⼀个 CMakeLists.txt ⽂件，该⽂件是必须的，cmake 根据这个⽂件来⽣成 Makefile。

win98 的CMakeLists.txt 内容如下add_executable(win98)假设 win2000 加⼊了新的⽹络功能，链接时需要⽤到 network 这个库⽂件，那么需要在 CMakeLists.txt 中指明add_executable(robot)target_link_libraries(win2000 network)src ⽬录下的 CMakeLists.txt 需要把它下属需要编译的⽬录都指定add_subdirectory(win98)add_subdirectory(win2000)在 win ⽬录下的 CMakeLists.txt ⽂件内容复杂⼀点，下⾯是个简单的例⼦# 指定版本和项⽬名称cmake_minimum_required(VERSION 2.6)project(windows CXX)# 指定源码⽬录add_subdirectory(src)在 win ⽬录下运⾏cmake . 后⾯有个点make整个⼯程编译完成，在 win98 和 win2000 下⾯就可以得到执⾏⽂件。

CMake之初级教程

CMake之初级教程(VTK)的过程中所产生的衍生品。

后来经过发展，最终形成体系，在2001年成为一个独立的开放源代码项目。

其*****是，可以通过访问*****来获得更多关于cmake 的信息，而且目前官方的英文文档比以前有了很大的改进，可以作为实践中的参考手册。

cmake的流行离不开KDE4的选择。

KDE开发者在使用autotools近10年之后，终于决定为KDE4项目选择一个新的工程构建工具。

之所以如此，用KDE开发者们自己话来说，就是：只有少数几个“编译专家”能够掌握KDE现在的构建体系。

在经历了unsermake，scons 以及cmake的选型和尝试之后，KDE4最终决定使用cmake作为自己的构建系统。

在迁移过程中，进展一场的顺利，并获得了cmake开发者的支持。

所以，目前的KDE4开发版本已经完全使用cmake来进行构建。

随着cmake 在KDE4项目中的成功，越来越多的项目正在使用cmake作为其构建工具，这也使得cmake正在成为一个主流的构建体系。

一、为何要使用项目构建工具？为何要使用cmake和autotools之类的项目构建工具？我想，这恐怕是刚刚接触软件项目的人最应该问的问题之一了。

“Hello, world！“这个最经典的程序相信我们每个人都写过。

无论在什么平台下，编译和运行这个程序都仅需要非常简单的操作。

但事实上，hello,world最多只能算是一个实例程序，根本算不上一个真正的软件项目。

任何一个软件项目，除了写代码之外，还有一个更为重要的任务，就是如何组织和管理这些代码，使项目代码层次结构清晰易读，这对以后的维护工作大有裨益。

使想一下，如果把一个像KDE4那么大的项目像hello world那样，把全部代码都放到一个main.cpp 文件中，那将会是多么恐怖的一件事情。

别说KDE4，就是我们随便一个几千行代码的小项目，也不会有人干这种蠢事。

决定代码的组织方式及其编译方式，也是程序设计的一部分。

CMake基础教程

CMake基础教程如果需要配置和检查我们⼯程中的所有依赖，那么可以选⽤CMake⼯具；但是，这并不是必须的，因为我们可以使⽤其他的⼯具或者是IDE(⽐如Makefiles或者Visual Studio)来配置我们的⼯程。

然⽽，CMake是最好移植的⽅式来配置多平台的C++项⽬。

1. 基本⽤法 CMake使⽤名称为CMakeLists.txt的⽂件，其中定义了编译和依赖处理等过程。

对于⼀个基本的项⽬⽽⾔，从⼀个源码⽂件构建⼀个可执⾏程序只需要中CMakeLists.txt⽂件中添加两⾏代码即可。

⽂件内容像下⾯这样：cmake_minimum_required (VERSION 2.6)project (CMakeTest)add_executable (${PROJECT_NAME} main.cpp) ⽂件的第⼀⾏定义了所需的CMake版本的最⼩值，这⼀⾏是强制添加在CMakeLists.txt⽂件中，其拥有指定了从第⼆⾏开始可以使⽤的给定版本所定义的cmake函数；第⼆⾏的project函数⽤于定义⼯程名(这⾥为CMakeTest)，这个名字被保存在⼀个名为PROJECT_NAME的变量中。

最后⼀⾏，在main.cpp⽂件中创建⼀个可执⾏命令(add_executable())，它的名字和⼯程名称(${PROJECT_NAME})相同，然后将源代码编译到名称为CMakeTest的可执⾏⽂件中，也就是将可执⾏⽂件名设置为与⼯程名相同。

${}表达式允许访问环境中定义的任何变量，因此，我们可以使⽤${PROJECT_NAME}变量作为⼀个可执⾏程序的输出名。

假设这⾥的main.cpp⽂件是⼀个简单的Hello World程序，代码如下：#include <iostream>using namespace std;int main(int argc, char *argv[]){cout << "Hello World! " << argc << argv[0] << endl;return0;}将这两个⽂件放置在同⼀⽬录下，然后依次执⾏如下命令：cmake .make这样，我们就可以在当前⽬录下⾯看到⼀个名称为CMakeTest的可执⾏⽂件了。

CMake if与option使用详解教程

CMake----if与option使用小记在CMake中if语法比较简单，if后面括号中的参数随着CMake版本的推进，在else 和endif中也可以不用写了。

if(address)else()endif()对于if语法，比较常用的就是字符串比较了，这里个人简单用到过两种，一种是这个变量有没有定义过。

有两种写法可以验证if(DEFINED address)else()endif()if(address)else()endif()两种都可以验证这个变量有没有定义过，注意：是定义过，比如你在CMake命令行中随便写了-Daddress=xxx,就表示定义过了，对里面的值没有任何要求。

第二中常用的用法就是字符串比较，比如if(${address} STREQUAL "ON")else()endif()当然去掉大括号也是可以比较的if(address STREQUAL "ON")else()endif()这种就是比较字符串的值了，注意：在这个时候，你的脚本已经假设你对于address已经有了已被定义的默认要求，也就是说此时如果你没有定义过address变量，在正常处理cmake ..的时候会报错，会提示无法识别的参数“STREQUAL”和"ON",这个需要特别注意。

还有就是如果真的要加上大括号来取值，适当加上双引号可以防止出现一些不必要的麻烦。

有的同学会问了，如果我就想有个默认值呢？如果我就想，当我自己不去设这个，我希望它存在，被定义过，并且有个自己的默认值，有没有办法？答案当然是有的，强大的CMake为我们准备了--option这个命令，给我们作为默认初始值并且作为定义值的候选。

option(address "This is a option for address" ON)此时表示，如果用户没有定义过address,那我address的默认值就是ON,如果用户在命令行显示改变过address的值比如为OFF,那么在脚本中address的值就是OFF。

CMake快速入门教程：实战

CMake快速入门教程：实战~/workspace/CRNode├─ src│ ├─ rpc│ │ ├─ CRMasterCaller.h│ │ ├─ │ │ ├─ CRNode.h│ │ ├─ │ │ ├─ Schd_constants.h│ │ ├─ Schd_│ │ ├─ CRMaster.h│ │ ├─ │ │ ├─ CRNode_server.skeleton.h│ │ ├─ CRNode_│ │ ├─ Schd_types.h│ │ └─ Schd_│ ├─ task│ │ ├─ TaskExecutor.h│ │ ├─ │ │ ├─ TaskMonitor.h│ │ └─ │ ├─ util│ │ ├─ Const.h│ │ ├─ │ │ ├─ Globals.h│ │ ├─ │ │ ├─ Properties.h│ │ ├─ │ │ ├─ utils.h│ │ └─ │ ├─ │ └─ CMakeLists.txt├─ doc│ └─ crnode.txt├─ COPYRIGHT├─ README├─ crnode.sh└─ CMakeLists.txt其中，src存放源代码文件和一个CMakeLists.txt文件，CMakeLists文件的编写我们稍候介绍；doc目录中存放项目的帮助文档，该文档以及COPYRIGHT和README一起安装到/usr/share/doc/crnode目录中；COPYRIGHT文件存放项目的版权信息，README存放一些说明性文字；crnode.sh存放CRNode的启动命令；CMakeLists.txt文件稍候介绍。

除此之外，项目还依赖两个外部库：Facebook开发的thrift库，其头文件存放在/usr/include/thrift目录中；log4cpp库，其头文件存放再/usr/include下。

2. CMakeLists.txt文件本工程中使用了两个CMakeLists.txt文件，分别项目的根目录（即~/workspace/CRNode目录，下同）和src目录中（参考以上目录结构）。

cmake教程

cmake教程cmake是一个开源的跨平台构建工具，它可以自动生成Makefile或Visual Studio的解决方案文件，从而实现项目的编译和构建。

本教程将介绍cmake的基本用法和常见的用法示例。

1. 安装cmakecmake可以在官方网站上下载并安装，在安装完成后，可以使用命令行中的cmake命令进行操作。

2. 创建一个基本的C++项目首先，创建一个空的文件夹作为项目的根目录。

在此目录下，创建一个C++源文件（例如main.cpp），并添加一些基本的C++代码。

3. 创建CMakeLists.txt文件在项目根目录下，创建一个名为CMakeLists.txt的文件。

这个文件将包含cmake的构建指令。

4. 编写CMakeLists.txt打开CMakeLists.txt文件，并编写cmake的构建指令。

以下是一个简单的示例：```# 设置项目的名称project(MyProject)# 指定要编译的源文件add_executable(MyProject main.cpp)```这段代码指定了项目的名称为MyProject，并将main.cpp作为需要编译的源文件。

你可以根据需要修改项目名称和源文件的路径。

5. 构建项目在命令行中，进入到项目根目录，并执行以下命令进行构建：```cmake .make```第一个命令将会生成Makefile，第二个命令将会使用Makefile 进行项目的编译和构建。

6. 运行项目在构建成功后，可以通过以下命令运行项目：```./MyProject```如果一切正常，你将会看到程序输出的结果。

以上仅是cmake的基本使用方法，它还有很多更高级的特性和用法，比如添加依赖库、选择构建类型等等。

你可以通过查阅相关的文档和官方网站来学习更多关于cmake的知识。

CC++从零开始的cmake教程

CC++从零开始的cmake教程C/C++从零开始的CMake教程如果你有过在linux系统上源码安装某款软件的经历，那么肯定对这三部曲⼀点都不会陌⽣——配置(configure)、编译(make)、安装(make install)。

⼏乎每次都是机器⼈般的操作，这背后其实是make（准确地说应该是GNU Make）在默默为你⼲了不少活。

1.编译hello.c——单⼀源⽂件的编译//hello.c#include <stdio.h>int main(){puts("hello, world!");return 0;}为了编译⽣成对应的可执⾏⽂件，你可能会使⽤下⾯的命令：$ cc -o hello hello.c$ ./hellohello, world!但是，如果使⽤make（前提是你的操作系统已经安装了GCC和GNU Make），会显得更清爽⼀些。

$ make hellocc hello.c -o hello$ ./hellohello, world!1.1编写Makefile什么？你连“make hello”都懒得写？看完这部分，你的“妄念”应该就能实现了，到时候你只需要慢悠悠地打出4个字母——”make”，然后按下回车键，⽐图形界⾯IDE还要⽅便（⾄少你不⽤到处去找那个该死的“运⾏”按钮在哪。

这时候你只要在hello.c的同⼀个⽬录下新建⼀个⽂件Makefile作为make命令的配置⽂件即可。

它的内容很简单：hello:1.2设定编译器什么？你不想使⽤默认的cc，⽽想使⽤gcc来编译程序？那还不简单，只⽤在Makefile⽂件中把CC变量的值赋为gcc就可以了。

CC := gcchello:如果你这时候想运⾏make试下效果，请注意：make根本就不会重新编译⽣成hello。

为什么啊？因为make很“懒”，因为它检测到hello.c和上⼀次编译时⼀模⼀样，再重新编译⽣成的可执⾏⽂件肯定也⼀样啊，那就没有运⾏的必要了，直接返回结果了。