cMake的使用

最新推荐文章于 2023-02-27 11:18:29 发布

芯想事程

最新推荐文章于 2023-02-27 11:18:29 发布

阅读量286

点赞数

分类专栏： linux开发遇到的问题嵌入式开发

本文链接：https://blog.csdn.net/qq_38074673/article/details/102585574

版权

嵌入式开发同时被 2 个专栏收录

41 篇文章 3 订阅

订阅专栏

linux开发遇到的问题

21 篇文章 0 订阅

订阅专栏

一、基本使用

安装：下载二进制包后可直接解压使用。

从源码安装则执行命令：

./bootstrap; ——尝试执行bootstrap失败

make;

make install

使用：cmake dir_path，生成工程文件或makefile文件

二、概念

out-of-source build，与in-source build相对，即将编译输出文件与放源文件到不同目录中；

三、基本结构

1，依赖CMakeLists.txt文件，项目主目标一个，主目录中可指定包含多个子目录；

2，在项目CMakeLists.txt中使用project指定项目名称，add_subdirectory添加子目录

3，子目录CMakeLists.txt将从父目录CMakeLists.txt继承设置（TBD，待检验）

四、语法

1. #注释

2. 变量：使用set命令显式定义及赋值，在非if语句中，使用${}引用，if中直接使用变量名引用；后续的set命令会清理变量原来的值；

3. 命令： command (args ...) #命令不分大小写，参数使用空格分隔，使用双引号引起参数中空格

4. set(var a;b;c) <==> set(var a b c) #定义变量var并赋值为a;b;c这样一个string list

5. Add_executable(${var}) <==> Add_executable(a b c) #变量使用${xxx}引用

6. 条件语句：

if(var) #var 非empty 0 N No OFF FALSE... #非运算使用NOT

…

else()/elseif() … endif(var)

7. 循环语句

Set(VAR a b c)

Foreach(f ${VAR}) …Endforeach(f)

8. 循环语句

WHILE() … ENDWHILE()

五、内部变量

CMAKE_C_COMPILER：指定C编译器

CMAKE_CXX_COMPILER：指定C++编译器

CMAKE_C_FLAGS：编译C文件时的选项，如-g；也可以通过add_definitions添加编译选项

EXECUTABLE_OUTPUT_PATH：可执行文件的存放路径

LIBRARY_OUTPUT_PATH：库文件路径

CMAKE_BUILD_TYPE: build 类型(Debug, Release, ...)，CMAKE_BUILD_TYPE=Debug

BUILD_SHARED_LIBS：Switch between shared and static libraries

内置变量的使用：

>> 在CMakeLists.txt中指定，使用set

>> cmake命令中使用，如cmake -DBUILD_SHARED_LIBS=OFF

六、命令

project (HELLO) #指定项目名称，生成的VC项目的名称；

include_directories：指定头文件的搜索路径，相当于指定gcc的-I参数

>>使用${HELLO_SOURCE_DIR}表示项目根目录

>> include_directories (${HELLO_SOURCE_DIR}/Hello) #增加Hello为include目录

link_directories：动态链接库或静态链接库的搜索路径，相当于gcc的-L参数

>> link_directories (${HELLO_BINARY_DIR}/Hello) #增加Hello为link目录

add_subdirectory：包含子目录

>> add_subdirectory (Hello)

add_executable：编译可执行程序，指定编译，好像也可以添加.o文件

>> add_executable (helloDemo demo.cxx demo_b.cxx) #将cxx编译成可执行文件

add_definitions：添加编译参数

>> add_definitions(-DDEBUG)将在gcc命令行添加DEBUG宏定义；

>> add_definitions( “-Wall -ansi –pedantic –g”)

target_link_libraries：添加链接库,相同于指定-l参数

>> target_link_libraries(demo Hello) #将可执行文件与Hello连接成最终文件demo

add_library:

>> add_library(Hello hello.cxx) #将hello.cxx编译成静态库如libHello.a

add_custom_target:

message( status|fatal_error, “message”):

set_target_properties( ... ): lots of properties... OUTPUT_NAME, VERSION, ....

link_libraries( lib1 lib2 ...): All targets link with the same set of libs

七、 FAQ

1）怎样获得一个目录下的所有源文件

>> aux_source_directory(<dir> <variable>)

>> 将dir中所有源文件（不包括头文件）保存到变量variable中，然后可以add_executable (ss7gw ${variable})这样使用。

2）怎样指定项目编译目标

>> project命令指定

3）怎样添加动态库和静态库

>> target_link_libraries命令添加即可

4）怎样在执行CMAKE时打印消息

>> message([SEND_ERROR | STATUS | FATAL_ERROR] "message to display" ...)

>> 注意大小写

5）怎样指定头文件与库文件路径

>> include_directories与link_directories

>>可以多次调用以设置多个路径

>> link_directories仅对其后面的targets起作用

6）怎样区分debug、release版本

>>建立debug/release两目录，分别在其中执行cmake -DCMAKE_BUILD_TYPE=Debug（或Release），需要编译不同版本时进入不同目录执行make即可；

Debug版会使用参数-g；Release版使用-O3 –DNDEBUG

>> 另一种设置方法——例如DEBUG版设置编译参数DDEBUG

IF(DEBUG_mode)

add_definitions(-DDEBUG)

ENDIF()

在执行cmake时增加参数即可，例如cmake -D DEBUG_mode=ON

7）怎样设置条件编译

例如debug版设置编译选项DEBUG，并且更改不应改变CMakelist.txt

>> 使用option command，eg：

option(DEBUG_mode "ON for debug or OFF for release" ON)

IF(DEBUG_mode)

add_definitions(-DDEBUG)

ENDIF()

>> 使其生效的方法：首先cmake生成makefile，然后make edit_cache编辑编译选项；Linux下会打开一个文本框，可以更改，该完后再make生成目标文件——emacs不支持make edit_cache；

>> 局限：这种方法不能直接设置生成的makefile，而是必须使用命令在make前设置参数；对于debug、release版本，相当于需要两个目录，分别先cmake一次，然后分别make edit_cache一次；

>> 期望的效果：在执行cmake时直接通过参数指定一个开关项，生成相应的makefile——可以这样做，例如cmake –DDEBUGVERSION=ON

8）怎样添加编译宏定义

>> 使用add_definitions命令，见命令部分说明

9）怎样添加编译依赖项

用于确保编译目标项目前依赖项必须先构建好

>>add_dependencies

10）怎样指定目标文件目录

>> 建立一个新的目录，在该目录中执行cmake生成Makefile文件，这样编译结果会保存在该目录——类似

>> SET_TARGET_PROPERTIES(ss7gw PROPERTIES

RUNTIME_OUTPUT_DIRECTORY "${BIN_DIR}")

11）很多文件夹，难道需要把每个文件夹编译成一个库文件？

>> 可以不在子目录中使用CMakeList.txt，直接在上层目录中指定子目录

12）怎样设定依赖的cmake版本

>>cmake_minimum_required(VERSION 2.6)

13）相对路径怎么指定

>> ${projectname_SOURCE_DIR}表示根源文件目录，${ projectname _BINARY_DIR}表示根二进制文件目录？

14）怎样设置编译中间文件的目录

>> TBD

15）怎样在IF语句中使用字串或数字比较

>>数字比较LESS、GREATER、EQUAL，字串比STRLESS、STRGREATER、STREQUAL，

>> Eg：

set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)

set(AAA abc)

IF(AAA STREQUAL abc)

message(STATUS "true") #应该打印true

ENDIF()

16）更改h文件时是否只编译必须的cpp文件

>> 是

17）机器上安装了VC7和VC8，CMAKE会自动搜索编译器，但是怎样指定某个版本？

>> TBD

18）怎样根据OS指定编译选项

>> IF( APPLE ); IF( UNIX ); IF( WIN32 )

19）能否自动执行某些编译前、后命令？

>> 可以，TBD

20）怎样打印make的输出

make VERBOSE=1

八、从“Hello, world!”开始

了解cmake的基本原理并在系统中安好cmake后，我们就可以用cmake来演示那个最经典的”Hello, world!”了。

第一步，我们给这个项目起个名字——就叫HELLO吧。因此，第一部为项目代码建立目录hello，与此项目有关的所有代码和文档都位于此目录下。

第二步，在hello目录下建立一个main.c文件，其代码如下：


 
 
   
   
    
    
   
   
   
   
    
           
     
     #include
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
            
     
     int main(void)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             {
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
                    
     
     printf(”Hello,Worldn”);
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
                    
     
     return 
     
     0;
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             }

至此，整个hello项目就已经构建完毕，可以进行编译了。

第三步，在hello目录下建立一个新的文件CMakeLists.txt，它就是 cmake所处理的“代码“。其实，使用cmake管理项目本身也是在编程，所以称之为“代码（或脚本）”并不为过。在CMakeLists.txt文件中输入下面的代码(#后面的内容为代码行注释)：
#cmake最低版本需求，不加入此行会受到警告信息
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)

#项目名称
PROJECT(HELLO)

#把当前目录(.)下所有源代码文件和头文件加入变量SRC_LIST
AUX_SOURCE_DIRECTORY(. SRC_LIST)

#生成应用程序 hello (在windows下会自动生成hello.exe)
ADD_EXECUTABLE(hello ${SRC_LIST})

第四步，编译项目。为了使用外部编译方式编译项目，需要先在目录hello下新建一个目录build(也可以是其他任何目录名)。现在，项目整体的目录结构为：
        hello/
        |– CMakeLists.txt
        |– build /
        |– main.c

在windows下，cmake提供了图形界面，设定hello为source目录，build为二进制目录，然后点击configure即可开始构建，之后进入build目录运行make命令编译。

在linux命令行下，首先进入目录build，然后运行命令(注：后面的“..”不可缺少)：

该命令使cmake检测编译环境，并生成相应的makefile。接着，运行命令make进行编译。编译后，生成的所有中间文件和可执行文件会在build目录下。 下面是我在ubuntu上的运行过程：


 
 
   
   
    
    
   
   
   
   
    
    
     
             $ ls
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             hello
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             $ cd hello/build/
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             $ ls
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             $ cmake ..
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – The C compiler identification is GNU
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – The CXX compiler identification is GNU
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Check 
     
     for working C compiler: /usr/bin/gcc
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Check 
     
     for working C compiler: /usr/bin/gcc — works
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Detecting C compiler ABI info
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
              – Detecting C compiler ABI info - done
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Check 
     
     for working CXX compiler: /usr/bin/c++
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Check 
     
     for working CXX compiler: /usr/bin/c++ — works
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Detecting CXX compiler ABI info
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Detecting CXX compiler ABI info - done
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Configuring done
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Generating done
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             – Build files have been written to: /home/kermit/Project/cmake/hello/build
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             $ make
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             Scanning dependencies of target hello
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             [
     
     100%] Building C object CMakeFiles/hello.dir/main.c.o
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             Linking C executable hello
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             [
     
     100%] Built target hello
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             $ ls
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             CMakeCache.txt CMakeFiles cmake_install.cmake hello Makefile
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             $ ./hello
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
             Hello,World

第一个问题：上面，我们提到了一个名词，叫外部编译方式。其实，cmake还可以直接在当前目录进行编译，无须建立build目录。但是，这种做法会将所有生成的中间文件和源代码混在一起，而且cmake生成的makefile无法跟踪所有的中间文件，即无法使用”make distclean”命令将所有的中间文件删除。因此，我们推荐建立build目录进行编译，所有的中间文件都会生成在build目录下，需要删除时直接清空该目录即可。这就是所谓的外部编译方式。

第二个问题： cmake 的手册详解：http://www.cnblogs.com/coderfenghc/archive/2012/06/16/CMake_ch_01.html

第三个问题：在Linux中使用cmake 构建应用程序： http://www.ibm.com/developerworks/cn/linux/l-cn-cmake/

CMake 是一个跨平台的自动化建构系统,它使用一个名为 CMakeLists.txt 的文件来描述构建过程,可以产生标准的构建文件,如 Unix 的 Makefile 或Windows Visual C++ 的 projects/workspaces 。文件 CMakeLists.txt 需要手工编写,也可以通过编写脚本进行半自动的生成。CMake 提供了比 autoconfig 更简洁的语法。在 linux 平台下使用 CMake 生成 Makefile 并编译的流程如下:

编写 CmakeLists.txt。
执行命令“cmake PATH”或者“ccmake PATH”生成 Makefile ( PATH 是 CMakeLists.txt 所在的目录 )。
使用 make 命令进行编译。

`第一个工程`

现假设我们的项目中只有一个源文件 main.cpp

清单1: 源文件 main.cpp


 
 
   
   
    
    
   
   
   
   
    
    
     
     1 
     
     #include<iostream>
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     2
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     3 
     
     int main()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     4 {
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     5 
     
     std::
     
     cout<<
     
     "Hello word!"<<
     
     std::
     
     endl;
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     6 
     
     return 
     
     0;
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     7 }

为了构建该项目,我们需要编写文件 CMakeLists.txt 并将其与 main.cpp 放在同一个目录下:

清单2: CMakeLists.txt


 
 
   
   
    
    
   
   
   
   
    
    
     
     PROJECT(main)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     CMAKE_MINIMUM_REQUIRED(VERSION 
     
     2.6)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     AUX_SOURCE_DIRECTORY(. DIR_SRCS)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     ADD_EXECUTABLE(main ${DIR_SRCS})


 
 
   
   
    
    
   
   
   
   
    
    
     
     CMakeLists.txt 的语法比较简单,由命令、注释和空格组成,其中命令是不区分大小写的,符号"#"后面的内容被认为是注释。命令由命令名称、小括号和参数组成,参数之间使用空格进行间隔。例如对于清单2的 CMakeLists.txt 文件:
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     第一行是一条命令,名称是 PROJECT ,参数是 main ,该命令表示项目的名称是 main 。
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     第二行的命令限定了 CMake 的版本。
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     第三行使用命令 AUX_SOURCE_DIRECTORY 将当前目录中的源文件名称赋值给变量 DIR_SRCS 。 CMake 手册中对命令 AUX_SOURCE_DIRECTORY 的描述如下:

aux_source_directory(<dir> <variable>)

该命令会把参数 <dir> 中所有的源文件名称赋值给参数 <variable> 。

第四行使用命令 ADD_EXECUTABLE 指示变量 DIR_SRCS 中的源文件需要编译成一个名称为 main 的可执行文件。

完成了文件 CMakeLists.txt 的编写后需要使用 cmake 或 ccmake 命令生成Makefile 。

ccmake 与命令 cmake 的不同之处在于 ccmake 提供了一个图形化的操作界面。cmake 命令的执行方式如下:

cmake [options] <path-to-source>

这里我们进入了 main.cpp 所在的目录后执行 “cmake .” 后就可以得到 Makefile 并使用 make 进行编译,如下图所示。

图1. camke的运行结果

camke 的运行结果

处理多源文件目录的方法

CMake处理源代码分布在不同目录中的情况也十分简单。现假设我们的源代码分布情况如下:

图 2. 源代码分布情况

源代码分布情况

其中 src 目录下的文件要编译成一个链接库。

第一步，项目主目录中的 CMakeLists.txt

在目录 step2 中创建文件 CMakeLists.txt 。文件内容如下:

清单3 目录 step2 中的 CMakeLists.txt


 
 
   
   
    
    
   
   
   
   
    
    
     
     PROJECT(main)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     CMAKE_MINIMUM_REQUIRED(VERSION 
     
     2.6) 
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     ADD_SUBDIRECTORY( src )
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     AUX_SOURCE_DIRECTORY(. DIR_SRCS)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     ADD_EXECUTABLE(main ${DIR_SRCS}  )
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     TARGET_LINK_LIBRARIES( main Test )

相对于清单 2，该文件添加了下面的内容:

第三行，使用命令 ADD_SUBDIRECTORY 指明本项目包含一个子目录 src 。

第六行，使用命令 TARGET_LINK_LIBRARIES 指明可执行文件 main 需要连接一个名为Test的链接库。

第二步，子目录中的 CmakeLists.txt

在子目录 src 中创建 CmakeLists.txt。文件内容如下:

清单 4. 目录 src 中的 CmakeLists.txt


 
 
   
   
    
    
   
   
   
   
    
    
     
     AUX_SOURCE_DIRECTORY(. DIR_TEST1_SRCS)
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     ADD_LIBRARY ( Test ${DIR_TEST1_SRCS})

在该文件中使用命令 ADD_LIBRARY 将 src 目录中的源文件编译为共享库。

第三步，执行 cmake

至此我们完成了项目中所有 CMakeLists.txt 文件的编写,进入目录 step2 中依次执行命令 “cmake .” 和 “make” 得到结果如下:

图3. 处理多源文件目录时 cmake 的执行结果

处理多源文件目录时 cmake 的执行结果

在执行 cmake 的过程中,首先解析目录 step2 中的 CMakeLists.txt ,当程序执行命令 ADD_SUBDIRECTORY( src ) 时进入目录 src 对其中的 CMakeLists.txt 进行解析。

在工程中查找并使用其他程序库的方法

在开发软件的时候我们会用到一些函数库,这些函数库在不同的系统中安装的位置可能不同,编译的时候需要首先找到这些软件包的头文件以及链接库所在的目录以便生成编译选项。例如一个需要使用博克利数据库项目,需要头文件db_cxx.h 和链接库 libdb_cxx.so ,现在该项目中有一个源代码文件 main.cpp ，放在项目的根目录中。

第一步，程序库说明文件

在项目的根目录中创建目录 cmake/modules/ ，在 cmake/modules/ 下创建文件 Findlibdb_cxx.cmake ，内容如下：

清单5. 文件 Findlibdb_cxx.cmake


 
 
   
   
    
    
   
   
   
   
    
    
     
     MESSAGE(STATUS 
     
     "Using bundled Findlibdb.cmake...")
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     FIND_PATH(
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        LIBDB_CXX_INCLUDE_DIR
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        db_cxx.h 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        /usr/include/ 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        /usr/local/include/ 
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        )
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     FIND_LIBRARY(
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        LIBDB_CXX_LIBRARIES NAMES  db_cxx
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        PATHS /usr/lib/ /usr/local/lib/
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
        )

文件 Findlibdb_cxx.cmake 的命名要符合规范: FindlibNAME.cmake ,其中NAME 是函数库的名称。Findlibdb_cxx.cmake 的语法与 CMakeLists.txt 相同。这里使用了三个命令： MESSAGE ， FIND_PATH 和 FIND_LIBRARY 。

命令 MESSAGE 会将参数的内容输出到终端。
命令 FIND_PATH 指明头文件查找的路径，原型如下：
find_path(<VAR> name1 [path1 path2 ...]) 该命令在参数 path* 指示的目录中查找文件 name1 并将查找到的路径保存在变量 VAR中。清单5第3－8行的意思是在 /usr/include/ 和 /usr/local/include/ 中查找文件db_cxx.h ,并将db_cxx.h 所在的路径保存在 LIBDB_CXX_INCLUDE_DIR中。
命令 FIND_LIBRARY 同 FIND_PATH 类似,用于查找链接库并将结果保存在变量中。清单5第10－13行的意思是在目录 /usr/lib/ 和 /usr/local/lib/ 中寻找名称为 db_cxx 的链接库,并将结果保存在 LIBDB_CXX_LIBRARIES。

`第二步, 项目的根目录中的 CmakeList.txt`

在项目的根目录中创建 CmakeList.txt ：

清单 6. 可以查找链接库的 CMakeList.txt

01 PROJECT(main)
02 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
03 SET(CMAKE_SOURCE_DIR .)
04 SET(CMAKE_MODULE_PATH ${CMAKE_ROOT}/Modules ${CMAKE_SOURCE_DIR}/cmake/modules)
05 AUX_SOURCE_DIRECTORY(. DIR_SRCS)
06 ADD_EXECUTABLE(main ${DIR_SRCS})
0708 FIND_PACKAGE( libdb_cxx REQUIRED)
09 MARK_AS_ADVANCED(
10 LIBDB_CXX_INCLUDE_DIR
11 LIBDB_CXX_LIBRARIES
12 )
13 IF (LIBDB_CXX_INCLUDE_DIR AND LIBDB_CXX_LIBRARIES)
14 MESSAGE(STATUS "Found libdb libraries")
15 INCLUDE_DIRECTORIES(${LIBDB_CXX_INCLUDE_DIR})
16 MESSAGE( ${LIBDB_CXX_LIBRARIES} )
17 TARGET_LINK_LIBRARIES(main ${LIBDB_CXX_LIBRARIES}18 )
19 ENDIF (LIBDB_CXX_INCLUDE_DIR AND LIBDB_CXX_LIBRARIES)

在该文件中第4行表示到目录 ./cmake/modules 中查找 Findlibdb_cxx.cmake ,8-19 行表示查找链接库和头文件的过程。第8行使用命令 FIND_PACKAGE 进行查找,这条命令执行后 CMake 会到变量 CMAKE_MODULE_PATH 指示的目录中查找文件 Findlibdb_cxx.cmake 并执行。第13-19行是条件判断语句,表示如果 LIBDB_CXX_INCLUDE_DIR 和 LIBDB_CXX_LIBRARIES 都已经被赋值,则设置编译时到 LIBDB_CXX_INCLUDE_DIR 寻找头文件并且设置可执行文件 main 需要与链接库 LIBDB_CXX_LIBRARIES 进行连接。

`第三步，执行 cmake`

完成 Findlibdb_cxx.cmake 和 CMakeList.txt 的编写后在项目的根目录依次执行 “cmake . ” 和 “make ” 可以进行编译,结果如下图所示：

图 4. 使用其他程序库时 cmake 的执行结果

使用其他程序库时 cmake 的执行结果

使用 cmake 生成 debug 版和 release 版的程序

在 Visual Studio 中我们可以生成 debug 版和 release 版的程序,使用 CMake 我们也可以达到上述效果。debug 版的项目生成的可执行文件需要有调试信息并且不需要进行优化,而 release 版的不需要调试信息但需要优化。这些特性在 gcc/g++ 中是通过编译时的参数来决定的,如果将优化程度调到最高需要设置参数-O3,最低是 -O0 即不做优化;添加调试信息的参数是 -g -ggdb ,如果不添加这个参数,调试信息就不会被包含在生成的二进制文件中。

CMake 中有一个变量 CMAKE_BUILD_TYPE ,可以的取值是 Debug Release RelWithDebInfo 和 MinSizeRel。当这个变量值为 Debug 的时候,CMake 会使用变量 CMAKE_CXX_FLAGS_DEBUG 和 CMAKE_C_FLAGS_DEBUG 中的字符串作为编译选项生成 Makefile ,当这个变量值为 Release 的时候,工程会使用变量 CMAKE_CXX_FLAGS_RELEASE 和 CMAKE_C_FLAGS_RELEASE 选项生成 Makefile。

现假设项目中只有一个文件 main.cpp ,下面是一个可以选择生成 debug 版和 release 版的程序的 CMakeList.txt ：

清单 7

1 PROJECT(main)
2 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
3 SET(CMAKE_SOURCE_DIR .)
45 SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g -ggdb")
6 SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3 -Wall")
78 AUX_SOURCE_DIRECTORY(. DIR_SRCS)
9 ADD_EXECUTABLE(main ${DIR_SRCS})

第 5 和 6 行设置了两个变量 CMAKE_CXX_FLAGS_DEBUG 和 CMAKE_CXX_FLAGS_RELEASE, 这两个变量是分别用于 debug 和 release 的编译选项。编辑 CMakeList.txt 后需要执行 ccmake 命令生成 Makefile 。在进入项目的根目录,输入 "ccmake ." 进入一个图形化界面,如下图所示：

图 5. ccmake 的界面

ccmake 的界面

按照界面中的提示进行操作,按 "c" 进行 configure ,这时界面中显示出了配置变量 CMAKE_BUILD_TYPE 的条目。如下图所示：

图 6. 执行了 configure 以后 ccmake 的界面

执行了 configure 以后 ccmake 的界面

下面我们首先生成 Debug 版的 Makefile ：将变量 CMAKE_BUILD_TYPE 设置为 Debug ,按 "c" 进行 configure ，按 "g" 生成 Makefile 并退出。这时执行命令 find * | xargs grep "O0" 后结果如下:

清单 8 find * | xargs grep "O0"的执行结果

CMakeFiles/main.dir/flags.make:CXX_FLAGS = -O0 -Wall -g -ggdb
CMakeFiles/main.dir/link.txt:/usr/bin/c++ -O0 -Wall -g -ggdb
CMakeFiles/main.dir/main.cpp.o -o main -rdynamic
CMakeLists.txt:SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g -ggdb")

这个结果说明生成的 Makefile 中使用了变量 CMAKE_CXX_FLAGS_DEBUG 作为编译时的参数。

下面我们将生成 Release 版的 Makefile ：再次执行命令 "ccmake ." 将变量CMAKE_BUILD_TYPE 设置为 Release ,生成 Makefile 并退出。执行命令 find * | xargs grep "O0" 后结果如下：

清单 9 find * | xargs grep "O0"的执行结果

CMakeLists.txt:SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g -ggdb")

而执行命令 find * | xargs grep "O3" 后结果如下:

清单 10. find * | xargs grep "O3"的执行结果

CMakeCache.txt:CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
CMakeCache.txt:CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
CMakeFiles/main.dir/flags.make:CXX_FLAGS = -O3 -Wall
CMakeFiles/main.dir/link.txt:/usr/bin/c++ -O3 -Wall
CMakeFiles/main.dir/main.cpp.o -o main -rdynamic
CMakeLists.txt:SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3 -Wall")

这两个结果说明生成的 Makefile 中使用了变量 CMAKE_CXX_FLAGS_RELEASE 作为编译时的参数。

芯想事程

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
cMake的使用

一、      基本使用安装：下载二进制包后可直接解压使用...
复制链接

扫一扫

专栏目录

cMake的使用

一、 基本使用

二、 概念

三、 基本结构

四、 语法

五、 内部变量

六、 命令

七、 FAQ

1） 怎样获得一个目录下的所有源文件

2） 怎样指定项目编译目标

3） 怎样添加动态库和静态库

4） 怎样在执行CMAKE时打印消息

5） 怎样指定头文件与库文件路径

6） 怎样区分debug、release版本

7） 怎样设置条件编译

8） 怎样添加编译宏定义

9） 怎样添加编译依赖项

10） 怎样指定目标文件目录

11） 很多文件夹，难道需要把每个文件夹编译成一个库文件？

12） 怎样设定依赖的cmake版本

13） 相对路径怎么指定

14） 怎样设置编译中间文件的目录

15） 怎样在IF语句中使用字串或数字比较

16） 更改h文件时是否只编译必须的cpp文件

17） 机器上安装了VC7和VC8，CMAKE会自动搜索编译器，但是怎样指定某个版本？

18） 怎样根据OS指定编译选项

19） 能否自动执行某些编译前、后命令？

20） 怎样打印make的输出

八、从“Hello, world!”开始

第一个工程

处理多源文件目录的方法

第一步，项目主目录中的 CMakeLists.txt

第二步，子目录中的 CmakeLists.txt

第三步，执行 cmake

在工程中查找并使用其他程序库的方法

第一步，程序库说明文件

第二步, 项目的根目录中的 CmakeList.txt

第三步，执行 cmake

使用 cmake 生成 debug 版和 release 版的程序

一、基本使用

二、概念

三、基本结构

四、语法

五、内部变量

六、命令

1）怎样获得一个目录下的所有源文件

2）怎样指定项目编译目标

3）怎样添加动态库和静态库

4）怎样在执行CMAKE时打印消息

5）怎样指定头文件与库文件路径

6）怎样区分debug、release版本

7）怎样设置条件编译

8）怎样添加编译宏定义

9）怎样添加编译依赖项

10）怎样指定目标文件目录

11）很多文件夹，难道需要把每个文件夹编译成一个库文件？

12）怎样设定依赖的cmake版本

13）相对路径怎么指定

14）怎样设置编译中间文件的目录

15）怎样在IF语句中使用字串或数字比较

16）更改h文件时是否只编译必须的cpp文件

17）机器上安装了VC7和VC8，CMAKE会自动搜索编译器，但是怎样指定某个版本？

18）怎样根据OS指定编译选项

19）能否自动执行某些编译前、后命令？

20）怎样打印make的输出

`第一个工程`

`第二步, 项目的根目录中的 CmakeList.txt`

`第三步，执行 cmake`