make与cmake入门

文章目录

  • 1. 手动链接与编译
  • 2. make编译工具
    • 2.1 介绍makefile
    • 2.2 makefile三要素
    • 2.3 make工作原理
    • 2.4 实战
      • 案例1
      • 案例2
      • 案例3
      • 案例4
    • 2.5 常见的自动化变量解析
  • 3. 使用cmake进行编译
    • 3.1 介绍cmake
    • 3.2 介绍CMakeLists.txt
    • 3.3 CMake安装
    • 3.4 实战案例
    • ==3.5 语法介绍==
      • 3.5.1 PROJECT关键字
      • 3.5.2 SET关键字
      • 3.5.3 MESSAGE关键字
      • 3.5.4 ADD_EXECUTABLE关键字
      • 3.5.5 cmake_minimum_required关键字
      • 3.5.6 include_directories关键字
      • 3.5.7 link_directories关键字
      • 3.5.8 add_library关键字
      • 3.5.9 add_compile_options关键字
      • 3.5.10 target_link_libraries关键字
      • 3.5.11 add_subdirectory关键字
      • 3.5.12 aux_source_directory关键字
    • ==3.5 Cmake 常用变量==
    • 3.6 语法的基本原则
      • 3.6.1语法注意事项
    • 3.7 内部构建和外部构建
      • ==3.7.1 外部构建方式举例==
    • 3.8 让编译可执行文件看起来更像一个工程
      • 3.8.1将目标文件放入构建目录的 bin 子目录
      • 3.8.2关于ADD_SUBDIRECTORY 指令
      • 3.8.3更改二进制的保存路径
    • 3.9 CMake项目的编译概述
  • 4. 使用cmake进行安装
    • 4.1 如何安装
      • 4.1.0 首先是需要创建目录树结构
      • 4.1.1 安装文件COPYRIGHT和README
      • 4.1.2 安装脚本runhello.sh
      • 4.1.3 安装 doc 中的 hello.txt
      • 4.1.3 安装过程
  • 5. 使用cmake进行静态库和动态库的构建
    • 5.0 构建实例
    • 5.1 ADD_LIBRARY关键字
    • 5.2 同时构建静态和动态库
    • 5.3 SET_TARGET_PROPERTIES关键字
    • 5.4 动态库的版本号
    • 5.5 安装共享库和头文件
    • 5.6 使用外部共享库和头文件
    • 5.7 解决:make后头文件找不到的问题
    • 5.8 解决:找到引用的函数问题
    • 5.9 找不到动态库
    • 5.10 特殊的环境变量 CMAKE_INCLUDE_PATH 和 CMAKE_LIBRARY_PATH
  • 6. 关于GNU, GCC,gcc,g++,Mingw,MSVC关系
    • GNU
    • GCC
    • gcc
    • g++
    • MingW
    • MSVC
  • 7. windows系统下:vscode中使用cmake和gdb:
    • 改写配置文件launch.json和tasks.json
  • 8. linux系统下:vscode中使用cmake和gdb:
  • 9. 参考博文:

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三要素

make与cmake入门_第1张图片

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

[目标] : [依赖] 	
	[命令](命令前面是tab制表符,不是空格)
  • 目标:规则的目标,可以是 Object File(一般称它为中间文件),也可以是可执行文件,还可以是一个标签;

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

  • 命令:make 需要执行的命令(任意的 shell 命令)。可以有多条命令,每一条命令占一行。

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

2.3 make工作原理

make与cmake入门_第2张图片

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

输出结果
make与cmake入门_第3张图片

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需要用变量去代替

  • _BINARY_DIR,本例中是 HELLO_BINARY_DIR

  • _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)

例如,生成了动态库和可执行文件,运行可执行文件的时候链接动态库
make与cmake入门_第4张图片

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_DIRPROJECT_BINARY_DIR_BINARY_DIR
  1. 这三个变量指代的内容是一致的
  2. 如果是 in binary build ,指的就是工程顶级目录
  3. 如果是 out-of-binary 编译,指的是工程编译发生的目录
  4. PROJECT_BINARY_DIR 跟其他指令稍有区别,但这里可以理解他们是一致的
  • CMAKE_SOURCE_DIRPROJECT_SOURCE_DIR_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}/

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

执行结果:
make与cmake入门_第5张图片

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

任务:

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

2,安装头文件与共享库。

静态库和动态库的区别

  • 静态库的扩展名一般为“.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 
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/

执行结果:
make与cmake入门_第6张图片

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)

输出结果:

make与cmake入门_第7张图片

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

执行结果:
make与cmake入门_第8张图片

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

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

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

main.cpp

#include 

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,然后选择:make与cmake入门_第9张图片
  4. 此时显示选择了GCC编译器,终端也会进行切换,同时文件夹里面也会创建build文件夹【自动】make与cmake入门_第10张图片
  5. 在终端依次输入cd .\buildcmake ..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文件自动编译新的可执行文件,如图,可以修改需要编译的文件,以及输出的可执行文件名
    make与cmake入门_第11张图片
  • 确保两处的名字是一致的
    make与cmake入门_第12张图片
  • 关联可执行文件

make与cmake入门_第13张图片

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

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

例如:在build文件路径下自动执行camke和make指令
make与cmake入门_第14张图片

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

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

9. 参考博文:

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

你可能感兴趣的:(linux,bash,运维)