make与cmake入门

1. 手动链接与编译

采用逐个编译

g++ cpp文件 -c	#会生成.o文件

生成可执行文件需要链接所有.o文件

g++ *.o -o main	#生成可执行文件

以上操作中过于繁琐

所有的g++编译的文件可以写成脚本，按照makefile格式进行编写

2. make编译工具

2.1 介绍makefile

• make 工具通过一个称为 makefile 的文件来完成并自动维护编译工作，执行make指令，make工具会在当前目录下找名字叫“Makefile”或“makefile”的文档，类似于执行脚本。

• makefile 需要按照某种语法进行编写，其中说明了如何编译各个源文件并连接生成可执行文件，并定义了源文件之间的依赖关系

• 当修改了其中某个源文件时，如果其他源文件依赖于该文件，则也要重新编译所有依赖该文件的源文件。

• 简单来说，make工具通过编写makefile来批量编译，取代了手动编写编译文档的工作量。但是当工程非常大的时候，手写makefile也是非常麻烦的，如果换了个平台makefile又要重新修改。

2.2 makefile三要素

基于三要素，接下来介绍makefile的基本格式

[目标] : [依赖] 	
	[命令]（命令前面是tab制表符，不是空格）

• 目标：规则的目标，可以是 Object File（一般称它为中间文件），也可以是可执行文件，还可以是一个标签；

• 依赖：是我们的依赖文件，要生成 targets 需要的文件或者是另一个目标。可以是多个，也可以是没有；

• 命令：make 需要执行的命令（任意的 shell 命令）。可以有多条命令，每一条命令占一行。

输入make命令会在当前路径下找到Makefile，或者也可以指定make -f Makefile

2.3 make工作原理

2.4 实战

案例1

hello: main.cpp printhello.cpp factorial.cpp
	g++ -o hello main.cpp printhello.cpp factorial.cpp

案例2

CXX = g++
TARGET = hello 
OBJ = main.o printhello.o factorial.o

$(TARGET): $(OBJ)
	$(CXX) -o $(TARGET) $(OBJ)

main.o: main.cpp
	$(CXX) -c main.cpp

printhello.o: printhello.cpp
	$(CXX) -c printhello.cpp

factorial.o: factorial.cpp
	$(CXX) -c factorial.cpp

案例3

CXX = g++
TARGET = hello 
OBJ = main.o printhello.o factorial.o

CXXFLAGS = -c -Wall #解除所有警告

$(TARGET): $(OBJ)
	$(CXX) -o $@ $^ #$@表示目标，$^表示依赖（所有）

%.o: %.cpp
	$(CXX) $(CXXFLAGS) $< -o $@ #$<表示依赖的第一个

.PHONY: clean
clean:
	rm -f *.o $(TARGET) # -f表示强制删除

.PHONY，makefile的特殊变量。以clean为例，第一种情况，我们不需要生成"clean"这个文件，另一种情况“clean”目标与文件"clean"重名时，目标不会执行。所以我们需要一个"伪目标"去执行makefile中的“clean”下面的命令。

案例4

CXX = g++
TARGET = hello 
SRC = $(wildcard *.cpp) #源文件为所有的cpp文件
OBJ = $(patsubst %.cpp, %.o, $(SRC))

CXXFLAGS = -c -Wall

$(TARGET): $(OBJ)
	$(CXX) -o $@ $^

%.o: %.cpp
	$(CXX) $(CXXFLAGS) $< -o $@

.PHONY: clean
clean:
	rm -f *.o $(TARGET)

2.5 常见的自动化变量解析

变量	解析
$0	当前脚本的文件名。
$n（n≥1）	传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个参数是 $1，第二个参数是 $2>。
$#	传递给脚本或函数的参数个数。
$*	传递给脚本或函数的所有参数。
$@	表示目标文件。
$?	上个命令的退出状态，或函数的返回值。
$$	当前 Shell 进程 ID。对于 Shell 脚本，就是这些脚本所在的进程 ID。
$^	表示所有的依赖文件
$<	表示第一个依赖文件

wildcard，用于防止通配符解析失败。使变量定义时，括号里的通配符仍然生效。

patsubst，用于防止替换文件解析失效。替换文件后缀。

3. 使用cmake进行编译

3.1 介绍cmake

• Cmake工具可以更加简单的生成makefile文件，执行make指令即可完成编译。当然cmake还有其他功能，就是可以跨平台生成对应平台能用的makefile，你不用自己去修改了。
• cmake的定义是什么 ？-----高级编译配置工具

3.2 介绍CMakeLists.txt

• 可是cmake根据什么生成makefile呢？它又要根据一个叫CMakeLists.txt文件（学名：组态档）去生成makefile。注意，文件名必须是CMakeLists.txt。

• CMakeLists.txt需要手动编写，但是它也有它的规则。

3.3 CMake安装

1、绝大多数的linux系统已经安装了CMake

cmake --version#查看是否安装cmake

如果没有安装则执行如下代码：

sudo apt-get install cmake

2、Windows或某些没有安装过的linux系统，去点我跳转可以下载安装

3.4 实战案例

CMakeList.txt

#CMakeLists.txt
PROJECT (HELLO)
SET(SRC_LIST main.cpp)
MESSAGE(STATUS "This is BINARY dir " ${HELLO_BINARY_DIR})
MESSAGE(STATUS "This is SOURCE dir "${HELLO_SOURCE_DIR})
ADD_EXECUTABLE(hello ${SRC_LIST})

创建build目录，便于清除cmake产生的除Makefile之外的多余文件

#创建build目录
mkdir build 
cd build

# build中编译
cmake .. 	#返回上一级目录中找到CMakeList.txt

# 构建 make或 cmake --build . 
cmake --build .  

执行生成的makefile

# 进入build文件中执行，要在makefile文件的路径下执行
make

输出结果

3.5 语法介绍

#CMakeLists.txt
PROJECT (HELLO)
SET(SRC_LIST main.cpp)
MESSAGE(STATUS "This is BINARY dir " ${HELLO_BINARY_DIR})
MESSAGE(STATUS "This is SOURCE dir "${HELLO_SOURCE_DIR})
ADD_EXECUTABLE(hello ${SRC_LIST})

3.5.1 PROJECT关键字

• 可以用来指定工程的名字和支持的语言，默认支持所有语言

  • PROJECT (HELLO) 指定了工程的名字，并且支持所有语言

  • PROJECT (HELLO CXX) 指定了工程的名字，并且支持语言是C++

  • PROJECT (HELLO C CXX Java) 指定了工程的名字，并且支持语言是C和C++和Java

该指定隐式定义了两个CMAKE的变量，projectname需要用变量去代替

• <projectname>_BINARY_DIR，本例中是 HELLO_BINARY_DIR

• <projectname>_SOURCE_DIR，本例中是 HELLO_SOURCE_DIR

MESSAGE关键字就可以直接使用者两个变量，当前都指向当前的工作目录，后面会讲外部编译

问题：如果改了工程名，这两个变量名也会改变
解决：可以定义两个预定义变量：PROJECT_BINARY_DIR和PROJECT_SOURCE_DIR，这两个变量和HELLO_BINARY_DIR，HELLO_SOURCE_DIR是一致的。所以改了工程名也没有关系

3.5.2 SET关键字

用来显示的指定变量的

SET(SRC_LIST main.cpp) ：SRC_LIST变量就包含了main.cpp

也可以 SET(SRC_LIST main.cpp t1.cpp t2.cpp)

3.5.3 MESSAGE关键字

向终端输出用户自定义的信息

主要包含三种信息：

• SEND_ERROR，产生错误，生成过程被跳过。
• SATUS，输出前缀为—— ——的信息。
• FATAL_ERROR，立即终止所有 cmake 过程.

3.5.4 ADD_EXECUTABLE关键字

• add_excutable : 生成可执行文件

ADD_EXECUTABLE(hello ${SRC_LIST}) 生成的可执行文件名是hello，源文件读取变量SRC_LIST中的内容

也可以直接写 ADD_EXECUTABLE(hello main.cpp)

上述例子可以简化的写成

PROJECT(HELLO)
ADD_EXECUTABLE(hello main.cpp)

注意：工程名的 HELLO 和生成的可执行文件 hello 是没有任何关系的

3.5.5 cmake_minimum_required关键字

• cmake_minimum_required : 指定cmake最小版本要求

# 指定cmake最小版本要求为 2.8.3
cmake_minimum_required(VERSION 2.8.3)

3.5.6 include_directories关键字

• include_directories : 向工程中添加多个头文件搜索路径，相当于指定 g++ 的 -I 参数

# 将 /usr/include 和 ./include 路径添加到头文件搜索路径中
include_directories(/usr/include ./include)

3.5.7 link_directories关键字

• link_directories : 向工程中添加多个库文件搜索路径，相当于 g++ 的 -L 参数

# 将 /usr/lib 和 ./lib 路径添加到库文件搜索路径中
link_directories(/usr/lib ./lib)

3.5.8 add_library关键字

• add_library : 生成库文件

# 通过变量SRC_LIST 生成hello.so 共享库，第二个参数填 SHARED 或 STATIC 或 MOUDLE
add_library(hello SHARED ${SRC_LIST })

3.5.9 add_compile_options关键字

• add_compile_options : 添加编译参数

# 添加编译参数 -Wall -std=c++11 以及 -o2
add_compile_options(-Wall -std=c++11 -o2)

3.5.10 target_link_libraries关键字

• target_link_libraries : 为目标可执行文件添加需要的共享库，相当于g++编译器的-l参数

# 将hello动态库文件链接到可执行文件main
target_link_libraries(main hello)

例如，生成了动态库和可执行文件，运行可执行文件的时候链接动态库

3.5.11 add_subdirectory关键字

• add_subdirectory : 向当前工程添加存放源文件的子目录，并可以指定中间二进制和目标二进制存放的位置

# 添加src子目录，src中需要有一个 CMakeLists.txt
add_subdirectory(src)

3.5.12 aux_source_directory关键字

• aux_source_directory : 发现一个目录下所有的源代码文件并将列表存储在一个变量中，这个指令临时被用来自动构建源文件列表。

# 定义 SRC 变量，其值为当前目录下所有的源代码文件
aux_source_directory(. SRC)
# 编译SRC 变量下的源代码文件，生成 mian 可执行文件
add_excutable(main ${
    
    SRC)

3.5 Cmake 常用变量

• CMAKE_FLAGS : gcc 编译选项
• CMAKE_CXX_FLAGS : g++ 的编译选项

# 在 CMAKE_CXX_FLAGS 编译选项后追加 -std=c++11
set(CMAKE_CXX_FLAGS "{CMAKE_CXX_FLAGS} -std=c++11")

• CMAKE_BUILD_TYPE : 编译类型(Debug，Release)

# 设定编译类型为 debug ，调试时需要选择 debug 
set(CMAKE_BUILD_TYPE Debug)
# 设定编译类型为release，发布时需要选择 release
set(CMAKE_BUILD_TYPE Release)

• CMAKE_BINARY_DIR、PROJECT_BINARY_DIR、<projectname>_BINARY_DIR

1. 这三个变量指代的内容是一致的
2. 如果是 in binary build ，指的就是工程顶级目录
3. 如果是 out-of-binary 编译，指的是工程编译发生的目录
4. PROJECT_BINARY_DIR 跟其他指令稍有区别，但这里可以理解他们是一致的

• CMAKE_SOURCE_DIR、PROJECT_SOURCE_DIR、<projectname>_SOURCE_DIR

1. 这三个变量指代的内容是一致的，不论采用何种编译方式，都是工程经层目录
2. 如果是 in source build ，跟 CMAKE_BINARY_DIR 变量一致
3. PROJECT_SOURCE_DIR 跟其他指令稍有区别，但这里可以理解他们是一致的

• CMAKE_C_COMPILE : 指定C编译器

• CMAKE_CXX_COMPILE : 指定C++编译器

• EXECUTABLE_OUT_PATH : 可执行文件输出的存放路径

• LIBRARY_OUTOUT_PATH : 库文件输出的存放路径

3.6 语法的基本原则

• 变量使用${}方式取值，但是在 IF 控制语句中是直接使用变量名

• 指令(参数 1 参数 2…) 参数使用括弧括起，参数之间使用空格或分号分开。 以上面的 ADD_EXECUTABLE 指令为例，如果存在另外一个 func.cpp 源文件

  就要写成：ADD_EXECUTABLE(hello main.cpp func.cpp)或者ADD_EXECUTABLE(hello main.cpp;func.cpp)

• 指令是大小写无关的，参数和变量是大小写相关的。推荐你全部使用大写指令

3.6.1语法注意事项

• SET(SRC_LIST main.cpp) 可以写成 SET(SRC_LIST “main.cpp”)，如果源文件名中含有空格，就必须要加双引号
• ADD_EXECUTABLE(hello main) 后缀可以不行，他会自动去找.c和.cpp，最好不要这样写，可能会有这两个文件main.cpp和main

3.7 内部构建和外部构建

• 上述例子就是内部构建，内部构建会产生很多中间文件，这些文件并不是我们最终想要的，和工程源代码文件放在一起会显得杂乱无章。
• 外部构建，就会把生成的临时文件放在build目录下，不会对源文件有任何影响强烈使用外部构建方式

内部构建示例

# 在项目源代码根目录下，使用  cmake 指令解析 CMakeLists.txt ，生成 Makefile 和其他文件
cmake .
# 执行 make 命令，生成 target
make

3.7.1 外部构建方式举例

1、建立一个build目录，可以在任何地方，建议在当前目录下

2、进入build，运行cmake .. 当然…表示上一级目录，你可以写CMakeLists.txt所在的绝对路径，生产的文件都在build目录下了

3、在build目录下，运行make来构建工程

注意外部构建的两个变量

• 1、HELLO_SOURCE_DIR 还是工程路径 也就是 /root/cmake【SOURCE表示源文件】

• 2、HELLO_BINARY_DIR 编译路径 也就是 /root/cmake/bulid【这里的BINARY也就是bin文件夹的简写，一般存放二进制可执行文件】

3.8 让编译可执行文件看起来更像一个工程

• 为工程添加一个子目录 src，用来放置工程源代码
• 添加一个子目录 doc，用来放置这个工程的文档 hello.txt
• 在工程目录添加文本文件 COPYRIGHT, README
• 在工程目录添加一个 runhello.sh 脚本，用来调用 hello 二进制
• 将构建后的目标文件放入构建目录的 bin 子目录
• 将 doc 目录 的内容以及 COPYRIGHT/README 安装到/usr/share/doc/cmake/

3.8.1将目标文件放入构建目录的 bin 子目录

每个目录下都要有一个CMakeLists.txt说明

[root@localhost cmake]# tree
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp

外层CMakeLists.txt

PROJECT(HELLO)
ADD_SUBDIRECTORY(src bin) #关联内部的CMakeLists.txt

src下的CMakeLists.txt

ADD_EXECUTABLE(hello main.cpp)

3.8.2关于ADD_SUBDIRECTORY 指令

ADD_SUBDIRECTORY(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

• 这个指令用于向当前工程添加存放源文件的子目录【source_dir变量】，并可以指定中间二进制和目标二进制存放的位置【binary_dir变量】

• EXCLUDE_FROM_ALL函数是将写的目录从编译中排除，如程序中的example

• ADD_SUBDIRECTORY(src bin)

  • 将 src 子目录加入工程并指定编译输出(包含编译中间结果)路径为bin 目录

  • 如果不进行 bin 目录的指定，那么编译结果(包括中间结果)都将存放在build/src 目录

3.8.3更改二进制的保存路径

SET 指令重新定义 EXECUTABLE_OUTPUT_PATH 和 LIBRARY_OUTPUT_PATH 变量 来指定最终的目标二进制的位置

SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)

思考：加载哪个CMakeLists.txt当中

哪里要改变目标存放路径，就在哪里加入上述的定义，所以应该在src下的CMakeLists.txt下写

3.9 CMake项目的编译概述

CMake项目的主要目录存在一个 CMakeLists.txt 文件

我们有两种当时设置编译规则

• 包含源文件的子文件夹包含 CMakeLists.txt 文件，主目录的 CMakeLists.txt 通过 add_subdirectory 添加子目录即可
• 包含源文件的子文件夹未包含 CMakeLists.txt 文件，子目录编译规则体现在主目录的 CMakeLists.txt 文件

4. 使用cmake进行安装

• 一种是从代码编译后直接 make install 安装
• 一种是打包时的指定 目录安装。
  • 简单的可以这样指定目录：make install DESTDIR=/tmp/test
  • 稍微复杂一点可以这样指定目录：./configure –prefix=/usr

4.1 如何安装

使用CMAKE一个新的指令：INSTALL

INSTALL的安装可以包括：二进制、动态库、静态库以及文件、目录、脚本等

使用CMAKE一个新的变量：CMAKE_INSTALL_PREFIX，指定安装目录，默认是在 /usr/local/

4.1.0 首先是需要创建目录树结构

// 目录树结构
[root@localhost cmake]# tree
.
├── build
├── CMakeLists.txt
├── COPYRIGHT
├── doc
│   └── hello.txt
├── README
├── runhello.sh
└── src
    ├── CMakeLists.txt
    └── main.cpp

4.1.1 安装文件COPYRIGHT和README

在外部CMakeLists.txt文件中添加如下指令

INSTALL(FILES COPYRIGHT README DESTINATION share/doc/cmake/)

• FILES：安装文件

• DESTINATION：

  • 1、可以写绝对路径

  • 2、可以写相对路径，相对路径实际路径是：${CMAKE_INSTALL_PREFIX}/<DESTINATION 定义的路径>

CMAKE_INSTALL_PREFIX 默认是在 /usr/local/，所以DESTINATION 的路径在/usr/local/share/doc/cmake/

ps：cmake -DCMAKE_INSTALL_PREFIX=/usr 在cmake的时候指定CMAKE_INSTALL_PREFIX变量的路径

4.1.2 安装脚本runhello.sh

INSTALL(PROGRAMS runhello.sh DESTINATION bin)

• PROGRAMS：非目标文件的可执行程序安装(比如脚本之类)

说明：实际安装到的是 /usr/bin

4.1.3 安装 doc 中的 hello.txt

• 一、是通过在 doc 目录建立CMakeLists.txt ，通过install下的file

• 二、是直接在工程目录通过

INSTALL(DIRECTORY doc/ DESTINATION share/doc/cmake)

• DIRECTORY 后面连接的是所在 Source 目录的相对路径

注意：abc 和 abc/有很大的区别

• 目录名不以/结尾：这个目录将被安装为目标路径下的

• 目录名以/结尾：将这个目录中的内容安装到目标路径

4.1.3 安装过程

cmake ..

make

make install

执行结果：

5. 使用cmake进行静态库和动态库的构建

任务：

１，建立一个静态库和动态库，提供 HelloFunc 函数供其他程序编程使用，HelloFunc 向终端输出 Hello World 字符串。

２，安装头文件与共享库。

静态库和动态库的区别

• 静态库的扩展名一般为“.a”或“.lib”；动态库的扩展名一般为“.so”或“.dll”。
• 静态库在编译时会直接整合到目标程序中，编译成功的可执行文件可独立运行
• 动态库在编译时不会放到连接的目标程序中，即可执行文件无法单独运行。

5.0 构建实例

[root@localhost cmake2]# tree
.
├── build
├── CMakeLists.txt
└── lib
    ├── CMakeLists.txt
    ├── hello.cpp
    └── hello.h

hello.h中的内容

#ifndef HELLO_H
#define Hello_H

void HelloFunc();

#endif

hello.cpp中的内容

#include "hello.h"
#include <iostream>
void HelloFunc(){
    
    
    std::cout << "Hello World" << std::endl;
}

外部CMakeLists.txt的内容

PROJECT(HELLO)
ADD_SUBDIRECTORY(lib bin)

lib中CMakeLists.txt中的内容

SET(LIBHELLO_SRC hello.cpp)
ADD_LIBRARY(hello SHARED ${
    
    LIBHELLO_SRC})

5.1 ADD_LIBRARY关键字

ADD_LIBRARY(hello SHARED ${LIBHELLO_SRC})

• hello：就是正常的库名，生成的名字前面会加上lib，最终产生的文件是libhello.so
• SHARED：表示动态库 ， STATIC：表示静态库
• ${LIBHELLO_SRC} ：源文件

运行：

cmake ..

make

cd bin/

执行结果：

5.2 同时构建静态和动态库

// 如果用这种方式，只会构建一个动态库，不会构建出静态库，虽然静态库的后缀是.a
ADD_LIBRARY(hello SHARED ${
    
    LIBHELLO_SRC})
ADD_LIBRARY(hello STATIC ${
    
    LIBHELLO_SRC})

// 修改静态库的名字，这样是可以的，但是我们往往希望他们的名字是相同的，只是后缀不同而已
ADD_LIBRARY(hello SHARED ${
    
    LIBHELLO_SRC})
ADD_LIBRARY(hello_static STATIC ${
    
    LIBHELLO_SRC})

5.3 SET_TARGET_PROPERTIES关键字

这条指令可以用来设置输出的名称，对于动态库，还可以用来指定动态库版本和 API 版本

同时构建静态和动态库

lib中CMakeLists.txt中的内容

SET(LIBHELLO_SRC hello.cpp)

ADD_LIBRARY(hello_static STATIC ${
    
    LIBHELLO_SRC})

//对hello_static的重名为hello
SET_TARGET_PROPERTIES(hello_static PROPERTIES  OUTPUT_NAME "hello")
//cmake 在构建一个新的target 时，会尝试清理掉其他使用这个名字的库，因为，在构建 libhello.so 时， 就会清理掉 libhello.a
SET_TARGET_PROPERTIES(hello_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)

ADD_LIBRARY(hello SHARED ${
    
    LIBHELLO_SRC})

SET_TARGET_PROPERTIES(hello PROPERTIES  OUTPUT_NAME "hello")
SET_TARGET_PROPERTIES(hello PROPERTIES CLEAN_DIRECT_OUTPUT 1)

输出结果：

5.4 动态库的版本号

一般动态库都有一个版本号的关联

libhello.so.1.2
libhello.so ->libhello.so.1
libhello.so.1->libhello.so.1.2

lib中CMakeLists.txt 插入如下

SET_TARGET_PROPERTIES(hello PROPERTIES VERSION 1.2 SOVERSION 1)

• VERSION 指代动态库版本
• SOVERSION 指代 API 版本。

5.5 安装共享库和头文件

本例中我们将 hello 的共享库安装到/lib目录，将 hello.h 安装到/include/hello 目录

lib中CMakeLists.txt中的内容

//文件放到该目录下
INSTALL(FILES hello.h DESTINATION include/hello)

//二进制，静态库，动态库安装都用TARGETS
//ARCHIVE 特指静态库，LIBRARY 特指动态库，RUNTIME 特指可执行目标二进制。
INSTALL(TARGETS hello hello_static LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)

注意：

安装的时候，指定一下路径，放到系统下

在build路径下执行：

cmake -D CMAKE_INSTALL_PREFIX=/usr ..

然后依次执行

make

make install

执行结果：

5.6 使用外部共享库和头文件

准备工作，新建一个目录来使用外部共享库和头文件

[root@MiWiFi-R4CM-srv cmake3]# tree
.
├── build
├── CMakeLists.txt
└── src
    ├── CMakeLists.txt
    └── main.cpp

main.cpp

#include <hello.h>

int main(){
    
    
	HelloFunc();
}

外部CMakeLists.txt的内容

PROJECT(HELLO)
ADD_SUBDIRECTORY(lib bin)

src中CMakeLists.txt中的内容

ADD_EXECUTABLE(hello main.cpp)

依次执行：

cmake ..

make

5.7 解决：make后头文件找不到的问题

报错信息：fatal error：hello.h：No such file or directory

关键字：INCLUDE_DIRECTORIES 这条指令可以用来向工程添加多个特定的头文件搜索路径，路径之间用空格分割

在src中CMakeLists.txt中加入头文件搜索路径

在最上面添加

INCLUDE_DIRECTORIES(/usr/include/hello)

5.8 解决：找到引用的函数问题

报错信息：undefined reference to `HelloFunc()’

方法一：关键字：LINK_DIRECTORIES 添加非标准的共享库搜索路径

• 指定第三方库所在路径，LINK_DIRECTORIES(/home/myproject/libs)

方法二：关键字：TARGET_LINK_LIBRARIES 添加需要链接的共享库

• TARGET_LINK_LIBRARIES的时候，只需要给出动态链接库的名字就行了。

• TARGET_LINK_LIBRARIES第一个参数和生成的可执行文件名相同

• 在CMakeLists.txt中插入链接共享库，主要要插在executable的后面

如果需要链接静态库，使用如下命令

TARGET_LINK_LIBRARIES(main libhello.a)

5.9 找不到动态库

报错信息：./hello: error while loading sharedlibraries:libhello.so:can not open shared object such file or directory

由于当前系统是63位的，需要将libs下的动态库移动到lib64下

执行：

mv usr/libs/libhello.so usr/lib64/

5.10 特殊的环境变量 CMAKE_INCLUDE_PATH 和 CMAKE_LIBRARY_PATH

注意：这两个是环境变量而不是 cmake 变量，可以在linux的bash中进行设置

我们上面例子中使用了绝对路径INCLUDE_DIRECTORIES(/usr/include/hello)来指明include路径的位置

我们还可以使用另外一种方式，使用环境变量export CMAKE_INCLUDE_PATH=/usr/include/hello

补充：正常是生成release版本，如要生产debug版本的方法：
cmake … -DCMAKE_BUILD_TYPE=debug

生成debug版本可以用gdb进行调试

6. 关于GNU, GCC，gcc，g++，Mingw，MSVC关系

GNU

• GNU是一个操作系统计划，由Richard Stallman在1983年发起，其目的是开发基于GPL协议的GNU操作系统内核hurd和GNU系统套件，其中就包括编译器部分。后来林纳斯开发出Linux内核，再后来GNU与Linux集成，诞生了完全自由的操作系统GNU\Linux或Linux。虽然GNU在开发操作系统上做出了杰出的贡献，但遗憾的是，GNU系统的内核hurd至今未能正式发布。

GCC

• GCC是GNU Compiler Collection（就是GNU编译器套件），也可以简单认为是编译器，它可以编译很多种编程语言（括C、C++、Objective-C、Fortran、Java等等）。

gcc

• gcc是GCC中的GUN C Compiler（C 编译器）。

g++

• g++是GCC中的GUN C++ Compiler（C++编译器）

MingW

• MinGW(Minimalist GNUfor Windows)，是GNU的windows版本。

MSVC

• MSVC是微软自己开发的C/C++编译器。

7. windows系统下：vscode中使用cmake和gdb：

1. 安装cmake tools工具，会包含cmake插件
2. 书写CMakeLists.txt
3. 按下ctrl+shift+p，选择CMake：Configure，然后选择：
4. 此时显示选择了GCC编译器，终端也会进行切换，同时文件夹里面也会创建build文件夹【自动】：
5. 在终端依次输入cd .\build，cmake .. ，mingw32-make.exe，终端会显示生成的可执行文件名，位置在build文件夹里面【注意：linux里面第三个指令是make，但是在windows下是mingw32-make.exe】
6. 修改launch.json，替换program属性值为该可执行文件

改写配置文件launch.json和tasks.json

• 如果注释了launch.jso文件里面的preLaunchTask字段，此时修改main.cpp文件后，再去调试时是执行原来的可执行文件
• 打开preLaunchTask字段，该字段的功能是根据taks.json文件自动编译新的可执行文件，如图，可以修改需要编译的文件，以及输出的可执行文件名
  
• 确保两处的名字是一致的
  
• 关联可执行文件

• 此时再按下F5调试，会生成新的可执行文件进行调试

总结：tasks.json文件的目的就是做调试之前的编译工作，程序员无须反复编译

例如：在build文件路径下自动执行camke和make指令

8. linux系统下：vscode中使用cmake和gdb：

查看博文：在Linux系统下使用GDB调试C++程序【命令行调试与vscode编译器调试】

9. 参考博文：

make的基础用法
cmake用法
gcc、g++编译详解
B站视频链接
VSCode的C++环境搭建，多文件编译，Cmake，json调试配置