CMakeLists 简单笔记

朴灿烈づ我的快乐病毒、 2022-11-14 14:50 183阅读 0赞

CMakeLists.txt用于组织c++文件及目录项，并根据CMakeLists.txt文件编写的规则cmake生成对应的可执行文件。CMakeLists.txt在Linux下编译及执行c++项目过程中是必不可少的利器。

【参数介绍】

PROJECT -------项目名称

SET -------设置编译参数如编译版本等

INCLUDE\_DIRECTORIES -------包含目录

LINK\_DIRECTORIES -------链接目录，即链接so的目录

add\_definitions --------增加一些宏定义内容

ADD\_SUBDIRECTORY --------增加包含子文件

ADD\_EXECUTABLE --------定义目标文件

TARGET\_LINK\_LIBRARIES --------将目标文件与库文件进行链接

ADD\_LIBRARY --------增加 so 文件，此句对应编译生成相应的so文件

#CMake的最低版本要求
    cmake_minimum_required(VERSION 2.8)
     
    #项目名称
    PROJECT (com.cffex.cts)
     
    #设置版本是 Debug 还是 Release
    SET(CMAKE_BUILD_TYPE "Debug")
     
    #设置编译所需的参数，其中参数 -Wall -o0 -g -ggdb 表示编译生成可调式的有调试信息的版本。
    SET(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS_DEBUG} -Wl,--rpath=./lib/ -m64 -Wall -o0 -g -ggdb -pthread -std=c++11 -fPIC")
     
    #设置 SRC_LIST 的值，在此指向main函数入口，用于生成可执行文件
    SET(SRC_LIST shell/src/Program.cpp)
     
    #设置包含目录 其中 #{CMAKE_CURRENT_BINARY_DIR} 表示build目录完全路径
    INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
     
    #设置输出目录
    SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/run)
     
    #添加include文件目录。放.h文件的目录
    INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/include/interface
    					${PROJECT_SOURCE_DIR}/include)
     
    #添加链接的 so 文件目录
    LINK_DIRECTORIES(${PROJECT_SOURCE_DIR}/lib
                     /usr/local/lib)
     
    #添加编译参数,比如add_definitions(-DDEBUG)将在gcc命令行添加DEBUG宏定义
    add_definitions(-D_TTS_)
    add_definitions(-g)
     
    #添加子目录
    ADD_SUBDIRECTORY(core)
     
    #添加可执行文件
    ADD_EXECUTABLE(shell ${SRC_LIST})
     
    #链接目标文件与可执行文件
    TARGET_LINK_LIBRARIES(shell core zookeeper_mt)

【示例2】

SET(SRC_LIST
            src/CTest.h
            src/CTest.cpp
            )
     
    SET(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/src)
     
    INCLUDE_DIRECTORIES(../include)
     
    #添加生成 testModule.so 文件
    ADD_LIBRARY(testModule SHARED ${SRC_LIST})
     
    #将 testModule 依赖的 so 包 link 进来
    TARGET_LINK_LIBRARIES(testModule core)
    TARGET_LINK_LIBRARIES(testModule utils)

#cmake 命令将 CMakeLists.txt 文件转换未MakeFiles文件
    cmake
    #make  命令 使用MakeFiles文件 进行编译。
    make

## 自定义变量 ##

主要有隐式定义和显式定义两种。  
隐式定义的一个例子是`PROJECT`指令，它会隐式的定义`< projectname >_BINARY_DIR`和`< projectname >_SOURCE_DIR`两个变量；显式定义使用`SET`指令构建自定义变量，比如:`SET(HELLO_SRCmain.c)`就可以通过`${HELLO_SRC}`来引用这个自定义变量了。

## 变量引用方式 ##

使用`${}`进行变量的引用；在`IF`等语句中,是直接使用变量名而不通过`${}`取值。

## 常用变量 ##

**CMAKE\_BINARY\_DIR**  
**PROJECT\_BINARY\_DIR**  
**< projectname >\_BINARY\_DIR**  
这三个变量指代的内容是一致的，如果是in-source编译，指得就是工程顶层目录；如果是out-of-source编译，指的是工程编译发生的目录。`PROJECT_BINARY_DIR`跟其它指令稍有区别，目前可以认为它们是一致的。

**CMAKE\_SOURCE\_DIR**  
**PROJECT\_SOURCE\_DIR**  
**< projectname >\_SOURCE\_DIR**  
这三个变量指代的内容是一致的，不论采用何种编译方式，都是工程顶层目录。也就是在in-source编译时,他跟`CMAKE_BINARY_DIR`等变量一致。`PROJECT_SOURCE_DIR`跟其它指令稍有区别,目前可以认为它们是一致的。  
（out-of-source build与in-source build相对，指是否在CMakeLists.txt所在目录进行编译。）

**CMAKE\_CURRENT\_SOURCE\_DIR**  
当前处理的CMakeLists.txt所在的路径，比如上面我们提到的src子目录。

**CMAKE\_CURRRENT\_BINARY\_DIR**  
如果是in-source编译，它跟`CMAKE_CURRENT_SOURCE_DIR`一致；如果是out-of-source编译，指的是target编译目录。使用`ADD_SUBDIRECTORY(src bin)`可以更改这个变量的值。使用`SET(EXECUTABLE_OUTPUT_PATH <新路径>)`并不会对这个变量造成影响,它仅仅修改了最终目标文件存放的路径。

**CMAKE\_CURRENT\_LIST\_FILE**  
输出调用这个变量的CMakeLists.txt的完整路径

**CMAKE\_CURRENT\_LIST\_LINE**  
输出这个变量所在的行

**CMAKE\_MODULE\_PATH**  
这个变量用来定义自己的cmake模块所在的路径。如果工程比较复杂，有可能会自己编写一些cmake模块，这些cmake模块是随工程发布的，为了让cmake在处理CMakeLists.txt时找到这些模块，你需要通过SET指令将cmake模块路径设置一下。比如`SET(CMAKE_MODULE_PATH,${PROJECT_SOURCE_DIR}/cmake)`  
这时候就可以通过INCLUDE指令来调用自己的模块了。

**EXECUTABLE\_OUTPUT\_PATH**  
新定义最终结果的存放目录

**LIBRARY\_OUTPUT\_PATH**  
新定义最终结果的存放目录

**PROJECT\_NAME**  
返回通过`PROJECT`指令定义的项目名称。

## cmake调用环境变量的方式 ##

使用$ENV\{NAME\}指令就可以调用系统的环境变量了。比如`MESSAGE(STATUS "HOME dir: $ENV{HOME}")`设置环境变量的方式是SET(ENV\{变量名\} 值)。

1.  **CMAKE\_INCLUDE\_CURRENT\_DIR**  
    自动添加`CMAKE_CURRENT_BINARY_DIR和CMAKE_CURRENT_SOURCE_DIR`到当前处理的CMakeLists.txt，相当于在每个CMakeLists.txt加入：`INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})`
2.  **CMAKE\_INCLUDE\_DIRECTORIES\_PROJECT\_BEFORE**  
    将工程提供的头文件目录始终置于系统头文件目录的前面,当定义的头文件确实跟系统发生冲突时可以提供一些帮助。
3.  **CMAKE\_INCLUDE\_PATH和CMAKE\_LIBRARY\_PATH**

## 系统信息 ##

*  `CMAKE_MAJOR_VERSION`，CMAKE主版本号，比如2.4.6中的2
 *  `CMAKE_MINOR_VERSION`，CMAKE次版本号，比如2.4.6中的4
 *  `CMAKE_PATCH_VERSION`，CMAKE补丁等级，比如2.4.6中的6
 *  `CMAKE_SYSTEM`，系统名称，比如Linux-2.6.22
 *  `CMAKE_SYSTEM_NAME`，不包含版本的系统名，比如Linux
 *  `CMAKE_SYSTEM_VERSION`，系统版本，比如2.6.22
 *  `CMAKE_SYSTEM_PROCESSOR`，处理器名称，比如i686
 *  `UNIX`，在所有的类Unix平台为`TRUE`，包括OSX和cygwin
 *  `WIN32`，在所有的Win32平台为`TRUE`，包括cygwin

## 主要的开关选项 ##

1.  **CMAKE\_ALLOW\_LOOSE\_LOOP\_CONSTRUCTS**  
    用来控制`IF ELSE`语句的书写方式。
2.  **BUILD\_SHARED\_LIBS**  
    这个开关用来控制默认的库编译方式。如果不进行设置，使用`ADD_LIBRARY`并没有指定库类型的情况下，默认编译生成的库都是静态库；如果`SET(BUILD_SHARED_LIBSON)`后,默认生成的为动态库。
3.  **CMAKE\_C\_FLAGS**  
    设置C编译选项，也可以通过指令`ADD_DEFINITIONS()`添加。
4.  **MAKE\_CXX\_FLAGS**  
    设置C++编译选项，也可以通过指令`ADD_DEFINITIONS()`添加。

## cMake常用指令 ##

这里引入更多的cmake指令,为了编写的方便,将按照cmakeman page 的顺序介绍各种指令，不再推荐使用的指令将不再介绍。

### 基本指令 ###

**PROJECT(HELLO)**  
指定项目名称，生成的VC项目的名称，使用`${HELLO_SOURCE_DIR}`表示项目根目录。

**INCLUDE\_DIRECTORIES**  
指定头文件的搜索路径，相当于指定gcc的-I参数  
`INCLUDE_DIRECTORIES(${HELLO_SOURCE_DIR}/Hello) #增加Hello为include目录`

**TARGET\_LINK\_LIBRARIES**  
添加链接库，相同于指定-l参数  
`TARGET_LINK_LIBRARIES(demoHello) #将可执行文件与Hello连接成最终文件demo`

**LINK\_DIRECTORIES**  
动态链接库或静态链接库的搜索路径，相当于gcc的-L参数  
`LINK_DIRECTORIES(${HELLO_BINARY_DIR}/Hello)#增加Hello为link目录`

**ADD\_DEFINITIONS**  
向C/C++编译器添加-D定义，比如：  
`ADD_DEFINITIONS(-DENABLE_DEBUG-DABC)`  
参数之间用空格分割。如果代码中定义了:

#ifdef ENABLE_DEBUG
    
    #endif

这个代码块就会生效。如果要添加其他的编译器开关,可以通过`CMAKE_C_FLAGS`变量和`CMAKE_CXX_FLAGS`变量设置。

**ADD\_DEPENDENCIES\***  
定义target依赖的其它target，确保在编译本target之前，其它的target已经被构建。`ADD_DEPENDENCIES(target-name depend-target1 depend-target2 ...)`

**ADD\_EXECUTABLE**  
`ADD_EXECUTABLE(helloDemo demo.cxx demo_b.cxx)`  
指定编译，好像也可以添加.o文件，将cxx编译成可执行文件

**ADD\_LIBRARY**  
`ADD_LIBRARY(Hellohello.cxx) #将hello.cxx编译成静态库如libHello.a`

**ADD\_SUBDIRECTORY**  
`ADD_SUBDIRECTORY(Hello) #包含子目录`

**ADD\_TEST**  
**ENABLE\_TESTING**  
`ENABLE_TESTING`指令用来控制Makefile是否构建test目标，涉及工程所有目录。语法很简单，没有任何参数，`ENABLE_TESTING()`一般放在工程的主CMakeLists.txt中。  
`ADD_TEST`指令的语法是:`ADD_TEST(testnameExename arg1 arg2 …)`  
testname是自定义的test名称，Exename可以是构建的目标文件也可以是外部脚本等等，后面连接传递给可执行文件的参数。

如果没有在同一个CMakeLists.txt中打开`ENABLE_TESTING()`指令，任何`ADD_TEST`都是无效的。比如前面的Helloworld例子,可以在工程主CMakeLists.txt中添加

ADD_TEST(mytest ${PROJECT_BINARY_DIR}/bin/main)
    ENABLE_TESTING

生成Makefile后，就可以运行`make test`来执行测试了。

**AUX\_SOURCE\_DIRECTORY**  
基本语法是:`AUX_SOURCE_DIRECTORY(dir VARIABLE)`，作用是发现一个目录下所有的源代码文件并将列表存储在一个变量中，这个指令临时被用来自动构建源文件列表，因为目前cmake还不能自动发现新添加的源文件。比如：

AUX_SOURCE_DIRECTORY(. SRC_LIST)
    ADD_EXECUTABLE(main ${SRC_LIST})

可以通过后面提到的`FOR EACH`指令来处理这个LIST。

**CMAKE\_MINIMUM\_REQUIRED**  
语法为`CMAKE_MINIMUM_REQUIRED(VERSION versionNumber [FATAL_ERROR])`，  
比如:`CMAKE_MINIMUM_REQUIRED(VERSION 2.5 FATAL_ERROR)`  
如果cmake版本小与2.5，则出现严重错误，整个过程中止。

**EXEC\_PROGRAM**  
在CMakeLists.txt处理过程中执行命令，并不会在生成的Makefile中执行。具体语法为:

EXEC_PROGRAM(Executable [directory in which to run] [ARGS <arguments to executable>] [OUTPUT_VARIABLE <var>] [RETURN_VALUE <var>])

用于在指定的目录运行某个程序，通过ARGS添加参数，如果要获取输出和返回值，可通过`OUTPUT_VARIABLE`和`RETURN_VALUE`分别定义两个变量。  
这个指令可以帮助在CMakeLists.txt处理过程中支持任何命令，比如根据系统情况去修改代码文件等等。举个简单的例子，我们要在src目录执行ls命令，并把结果和返回值存下来，可以直接在src/CMakeLists.txt中添加：

EXEC_PROGRAM(ls ARGS "*.c" OUTPUT_VARIABLE LS_OUTPUT RETURN_VALUE LS_RVALUE)
    IF(not LS_RVALUE)
        MESSAGE(STATUS "ls result: " ${LS_OUTPUT})
    ENDIF(not LS_RVALUE)

在cmake生成Makefile过程中，就会执行ls命令，如果返回0，则说明成功执行，那么就输出`ls *.c`的结果。关于`IF`语句，后面的控制指令会提到。

**FILE指令**  
文件操作指令，基本语法为:

FILE(WRITEfilename "message to write"... )
    FILE(APPENDfilename "message to write"... )
    FILE(READfilename variable)
    FILE(GLOBvariable [RELATIVE path] [globbing expression_r_rs]...)
    FILE(GLOB_RECURSEvariable [RELATIVE path] [globbing expression_r_rs]...)
    FILE(REMOVE[directory]...)
    FILE(REMOVE_RECURSE[directory]...)
    FILE(MAKE_DIRECTORY[directory]...)
    FILE(RELATIVE_PATHvariable directory file)
    FILE(TO_CMAKE_PATHpath result)
    FILE(TO_NATIVE_PATHpath result)

**INCLUDE指令**  
用来载入CMakeLists.txt文件，也用于载入预定义的cmake模块。

INCLUDE(file1[OPTIONAL])
    INCLUDE(module[OPTIONAL])

OPTIONAL参数的作用是文件不存在也不会产生错误，可以指定载入一个文件，如果定义的是一个模块，那么将在CMAKE\_MODULE\_PATH中搜索这个模块并载入，载入的内容将在处理到INCLUDE语句是直接执行。

**INSTALL指令**

**FIND\_指令**  
FIND\_系列指令主要包含一下指令:

FIND_FILE(<VAR>name1 path1 path2 …)    VAR变量代表找到的文件全路径,包含文件名
    FIND_LIBRARY(<VAR>name1 path1 path2 …)    VAR变量表示找到的库全路径,包含库文件名
    FIND_PATH(<VAR>name1 path1 path2 …)   VAR变量代表包含这个文件的路径
    FIND_PROGRAM(<VAR>name1 path1 path2 …)   VAR变量代表包含这个程序的全路径
    FIND_PACKAGE(<name>[major.minor] [QUIET] [NO_MODULE] [[REQUIRED|COMPONENTS][componets...]])   用来调用预定义在CMAKE_MODULE_PATH下的Find<name>.cmake模块，也可以自己定义Find<name>模块，通过SET(CMAKE_MODULE_PATH dir)将其放入工程的某个目录中供工程使用，后面会详细介绍FIND_PACKAGE的使用方法和Find模块的编写。

FIND\_LIBRARY示例:

FIND_LIBRARY(libXX11 /usr/lib)
    IF(NOT libX)
        MESSAGE(FATAL_ERROR "libX not found")
    ENDIF(NOT libX)

### 控制指令 ###

IF指令，基本语法为:

IF(expression_r_r)
        #THEN section.
        COMMAND1(ARGS…)
        COMMAND2(ARGS…)
        …
    ELSE(expression_r_r)
        #ELSE section.
        COMMAND1(ARGS…)
        COMMAND2(ARGS…)
        …
    ENDIF(expression_r_r)

另外一个指令是`ELSEIF`，总体把握一个原则，凡是出现IF的地方一定要有对应的`ENDIF`，出现`ELSEIF`的地方，`ENDIF`是可选的。表达式的使用方法如下:

IF(var)  如果变量不是：空, 0, N, NO, OFF, FALSE, NOTFOUND 或 <var>_NOTFOUND时，表达式为真。
    IF(NOT var)， 与上述条件相反。
    IF(var1AND var2)， 当两个变量都为真是为真。
    IF(var1OR var2)， 当两个变量其中一个为真时为真。
    IF(COMMANDcmd)， 当给定的cmd确实是命令并可以调用是为真。
    IF(EXISTS dir) or IF(EXISTS file)， 当目录名或者文件名存在时为真。
    IF(file1IS_NEWER_THAN file2)， 当file1比file2新，或者file1/file2其中有一个不存在时为真文件名请使用完整路径。
    IF(IS_DIRECTORY dirname),  当dirname是目录时为真。
    IF(variableMATCHES regex)

`IF(string MATCHES regex)` 当给定的变量或者字符串能够匹配正则表达式`regex`时为真。比如:

IF("hello" MATCHES "hello")
        MESSAGE("true")
    ENDIF("hello" MATCHES "hello")

IF(variable LESS number)
    IF(string LESS number)
    IF(variable GREATER number)
    IF(string GREATER number)
    IF(variable EQUAL number)
    IF(string EQUAL number)

**数字比较表达式**

IF(variable STRLESS string)
    IF(string STRLESS string)
    IF(variable STRGREATER string)
    IF(string STRGREATER string)
    IF(variable STREQUAL string)
    IF(string STREQUAL string)

按照字母序的排列进行比较。

`IF(DEFINED variable)`，如果变量被定义，为真。  
一个小例子,用来判断平台差异:

IF(WIN32)
        MESSAGE(STATUS“This is windows.”) #作一些Windows相关的操作
    ELSE(WIN32)
        MESSAGE(STATUS“This is not windows”) #作一些非Windows相关的操作
    ENDIF(WIN32)

上述代码用来控制在不同的平台进行不同的控制,但是阅读起来却并不是那么舒服, `ELSE(WIN32)`之类的语句很容易引起歧义。  
这就用到了我们在 常用变量 一节提到的`CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS`开关。可以`SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTSON)`，这时候就可以写成:

IF(WIN32)
    
    ELSE()
    
    ENDIF()

如果配合ELSEIF使用,可能的写法是这样:

IF(WIN32)
        #dosomething related to WIN32
    ELSEIF(UNIX)
        #dosomething related to UNIX
    ELSEIF(APPLE)
        #dosomething related to APPLE
    ENDIF(WIN32)

WHILE指令

WHILE指令的语法是:

WHILE(condition)
        COMMAND1(ARGS…)
        COMMAND2(ARGS…)
        …
    ENDWHILE(condition)

其真假判断条件可以参考IF指令。

FOREACH指令

FOREACH指令的使用方法有三种形式:  
**(1)列表**

FOREACH(loop_vararg1 arg2 …)
        COMMAND1(ARGS…)
        COMMAND2(ARGS…)
        …
    ENDFOREACH(loop_var)

像我们前面使用的`AUX_SOURCE_DIRECTORY`的例子

AUX_SOURCE_DIRECTORY(.SRC_LIST)
    FOREACH(F ${SRC_LIST})
        MESSAGE(${F})
    ENDFOREACH(F)

**(2)范围**

FOREACH(loop_var RANGE total)
    
    ENDFOREACH(loop_var)

从0到total以1为步进，举例如下:

FOREACH(VARRANGE 10)
        MESSAGE(${VAR})
    ENDFOREACH(VAR)

最终得到的输出是:

0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

**(3)范围和步进**

FOREACH(loop_var RANGE start stop [step])
    
    ENDFOREACH(loop_var)

从start开始到stop结束，以step为步进。举例如下:

FOREACH(A RANGE 5 15 3)
        MESSAGE(${A})
    ENDFOREACH(A)

最终得到的结果是:

5
    8
    11
    14

这个指令需要注意的是，直到遇到`ENDFOREACH`指令，整个语句块才会得到真正的执行。

## 复杂的例子:模块的使用和自定义模块 ##

这里将着重介绍系统预定义的Find模块的使用以及自己编写Find模块，系统中提供了其他各种模块，一般情况需要使用`INCLUDE`指令显式的调用，`FIND_PACKAGE`指令是一个特例，可以直接调用预定义的模块。

其实纯粹依靠cmake本身提供的基本指令来管理工程是一件非常复杂的事情，所以cmake设计成了可扩展的架构，可以通过编写一些通用的模块来扩展cmake。

首先介绍一下cmake提供的`FindCURL`模块的使用，然后基于前面的`libhello`共享库，编写一个`FindHello.cmake`模块。  
**（一）使用FindCURL模块**  
在/backup/cmake目录建立t5目录,用于存放CURL的例子。  
建立src目录,并建立src/main.c,内容如下:

#include<curl/curl.h>
    #include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    
    FILE*fp;
    
    intwrite_data(void *ptr, size_t size, size_t nmemb, void *stream)
    
    {
        int written = fwrite(ptr, size, nmemb, (FILE *)fp);
        return written;
    }
    
    int main()
    {
        const char *path = “/tmp/curl-test”;
        const char *mode = “w”;
        fp = fopen(path,mode);
        curl_global_init(CURL_GLOBAL_ALL);
        CURL coderes;
        CURL *curl = curl_easy_init();
    
        curl_easy_setopt(curl, CURLOPT_URL, “http://www.linux-ren.org”);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
        res = curl_easy_perform(curl);
        curl_easy_cleanup(curl);
    }

这段代码的作用是通过curl取回`www.linux-ren.org`的首页并写入`/tmp/curl-test`文件中

建立主工程文件`CmakeLists.txt`，如下：

PROJECT(CURLTEST)
    ADD_SUBDIRECTORY(src)

建立src/CmakeLists.txt

ADD_EXECUTABLE(curltest main.c)

现在自然是没办法编译的，我们需要添加curl的头文件路径和库文件。

**方法1:**  
直接通过`INCLUDE_DIRECTORIES`和`TARGET_LINK_LIBRARIES`指令添加:

我们可以直接在`src/CMakeLists.txt`中添加:

INCLUDE_DIRECTORIES(/usr/include)
    TARGET_LINK_LIBRARIES(curltestcurl)

然后建立build目录进行外部构建即可。  
现在要探讨的是使用cmake提供的FindCURL模块。

**方法2:**  
使用`FindCURL`模块。向`src/CMakeLists.txt`中添加:

FIND_PACKAGE(CURL)
    IF(CURL_FOUND)
        INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIR})
        TARGET_LINK_LIBRARIES(curltest${CURL_LIBRARY})
    ELSE(CURL_FOUND)
        MESSAGE(FATAL_ERROR”CURL library not found”)
    ENDIF(CURL_FOUND)

对于系统预定义的`Find<name>.cmake`模块,使用方法一般如上例所示，每一个模块都会定义以下几个变量:

<name>_FOUND
    <name>_INCLUDE_DIR or <name>_INCLUDES
    <name>_LIBRARY or <name>_LIBRARIES

可以通过`<name>_FOUND`来判断模块是否被找到，如果没有找到，按照工程的需要关闭某些特性、给出提醒或者中止编译，上面的例子就是报出致命错误并终止构建。  
如果`<name>_FOUND`为真，则将`<name>_INCLUDE_DIR`加入`INCLUDE_DIRECTORIES`，将`<name>_LIBRARY`加入`TARGET_LINK_LIBRARIES`中。

我们再来看一个复杂的例子,通过`<name>_FOUND`来控制工程特性:

SET(mySourcesviewer.c)
    SET(optionalSources)
    SET(optionalLibs)
    
    FIND_PACKAGE(JPEG)
    
    IF(JPEG_FOUND)
        SET(optionalSources${optionalSources} jpegview.c)
        INCLUDE_DIRECTORIES(${JPEG_INCLUDE_DIR} )
        SET(optionalLibs${optionalLibs} ${JPEG_LIBRARIES} )
        ADD_DEFINITIONS(-DENABLE_JPEG_SUPPORT)
    ENDIF(JPEG_FOUND)
    
    IF(PNG_FOUND)
        SET(optionalSources${optionalSources} pngview.c)
        INCLUDE_DIRECTORIES(${PNG_INCLUDE_DIR} )
        SET(optionalLibs${optionalLibs} ${PNG_LIBRARIES} )
        ADD_DEFINITIONS(-DENABLE_PNG_SUPPORT)
    ENDIF(PNG_FOUND)
    
    ADD_EXECUTABLE(viewer${mySources} ${optionalSources}
    TARGET_LINK_LIBRARIES(viewer${optionalLibs}

通过判断系统是否提供了JPEG库来决定程序是否支持JPEG功能。

**（二）编写属于自己的FindHello模块**  
接下来在t6示例中演示如何自定义`FindHELLO`模块并使用这个模块构建工程。在`/backup/cmake/`中建立t6目录，并在其中建立cmake目录用于存放我们自己定义的`FindHELLO.cmake`模块，同时建立src目录，用于存放我们的源文件。

1.定义`cmake/FindHELLO.cmake`模块

FIND_PATH(HELLO_INCLUDE_DIR hello.h /usr/include/hello /usr/local/include/hello)
    
    FIND_LIBRARY(HELLO_LIBRARY NAMES hello PATH /usr/lib /usr/local/lib)
    
    IF(HELLO_INCLUDE_DIR AND HELLO_LIBRARY)
        SET(HELLO_FOUNDTRUE)
    ENDIF(HELLO_INCLUDE_DIR AND HELLO_LIBRARY)
    
    IF(HELLO_FOUND)
        IF(NOT HELLO_FIND_QUIETLY)
            MESSAGE(STATUS"Found Hello: ${HELLO_LIBRARY}")
        ENDIF(NOT HELLO_FIND_QUIETLY)
    ELSE(HELLO_FOUND)
        IF(HELLO_FIND_REQUIRED)
            MESSAGE(FATAL_ERROR"Could not find hello library")
        ENDIF(HELLO_FIND_REQUIRED)
    ENDIF(HELLO_FOUND)

针对上面的模块让我们再来回顾一下`FIND_PACKAGE`指令:

FIND_PACKAGE(<name>[major.minor] [QUIET] [NO_MODULE] [[REQUIRED|COMPONENTS][componets...]])

前面的CURL例子中我们使用了最简单的`FIND_PACKAGE`指令，其实它可以使用多种参数：

`QUIET`参数，对应与我们编写的`FindHELLO`中的`HELLO_FIND_QUIETLY`，如果不指定这个参数,就会执行:

MESSAGE(STATUS"Found Hello: ${HELLO_LIBRARY}")

`REQUIRED`参数，其含义是指这个共享库是否是工程必须的，如果使用了这个参数，说明这个链接库是必备库,如果找不到这个链接库,则工程不能编译。对应于`FindHELLO.cmake`模块中的`HELLO_FIND_REQUIRED`变量。  
同样,我们在上面的模块中定义了`HELLO_FOUND`,`HELLO_INCLUDE_DIR`, `HELLO_LIBRARY`变量供开发者在`FIND_PACKAGE`指令中使用。

下面建立`src/main.c`,内容为:

#include<hello.h>
    int main()
    {
        HelloFunc();
        return 0;
    }

建立`src/CMakeLists.txt`文件,内容如下:

FIND_PACKAGE(HELLO)
    IF(HELLO_FOUND)
        ADD_EXECUTABLE(hellomain.c)
        INCLUDE_DIRECTORIES(${HELLO_INCLUDE_DIR})
        TARGET_LINK_LIBRARIES(hello${HELLO_LIBRARY})
    ENDIF(HELLO_FOUND)

为了能够让工程找到 FindHELLO.cmake 模块(存放在工程中的cmake目录)我们在主工程文件 CMakeLists.txt 中加入:

SET(CMAKE_MODULE_PATH${PROJECT_SOURCE_DIR}/cmake)

**（三）使用自定义的FindHELLO模块构建工程**  
仍然采用外部编译的方式,建立build目录,进入目录运行:

cmake ..

我们可以从输出中看到:

FoundHello: /usr/lib/libhello.so

如果我们把上面的`FIND_PACKAGE(HELLO)`修改为`FIND_PACKAGE(HELLO QUIET)`,

不会看到上面的输出。接下来就可以使用make命令构建工程,运行:

./src/hello

可以得到输出

HelloWorld

说明工程成功构建。