Linux环境下基于VSCode和CMake实现C/C++开发

---

layout: post
title: 开发工具（一）Linux环境下基于VSCode和CMake实现C/C++开发
description:开发工具（一）Linux环境下基于VSCode和CMake实现C/C++开发
tag: 开发工具

---

Linux开发环境

Linux目录结构

常用指令选项

ls：list directory contents

cd：change directory

touch：change file timestamps

man/help 查看用户指令手册

开发环境搭建

编译器GCC，调试器GDB安装

1. 安装GCC，GDB

sudo apt update
# 通过以下指令安装编译器和调试器
sudo apt install build-essential gdb
1
2
3

2. 安装成功确认

# 以下命令确认每个软件是否安装成功
# 如果成功，则显示版本号
gcc --version
g++ --version
gdb --version
1
2
3
4
5

安装跨平台编译工具CMake

安装cmake，确认是否安装成功

sudo apt install cmake
cmake --version
1
2

GCC编译器

前言：

1. GCC 编译器支持编译 Go、Objective-C，Objective-C ++，Fortran，Ada，D 和 BRIG（HSAIL）
   等程序；
2. Linux 开发C/C++ 一定要熟悉 GCC
3. VSCode是通过调用GCC编译器来实现C/C++的编译工作的；
4. 实际使用中：
   使用 gcc 指令编译 C 代码
   使用 g++指令编译 C++ 代码

编译过程

1. 预处理 // 生成预处理后的.i文件
2. 编译 // 生成汇编语言的.s文件
3. 汇编 // 生成机器语言的.o文件
4. 链接// 生成可执行的bin文件

# 1-E 选项指示编译器仅对输入文件进行预处理
g++ -E test.cpp -o test.i //.i文件

# 2-S 编译选项告诉 g++ 在为 C++ 代码产生了汇编语言文件后停止编译
# g++ 产生的汇编语言文件的缺省扩展名是 .s
g++ -S test.i -o test.s

# 3-c 选项告诉 g++ 仅把源代码编译为机器语言的目标代码
# 缺省时 g++ 建立的目标代码文件有一个 .o 的扩展名。
g++ -c test.s -o test.o

# 4-o 编译选项来为将产生的可执行文件用指定的文件名
g++ test.o -o test
1
2
3
4
5
6
7
8
9
10
11
12
13

实际使用中一个cpp文件可以直接使用一个指令完成：

g++ test.cpp -o test
1

g++重要编译参数

1. -g 编译带调试信息的可执行文件

# -g 选项告诉 GCC 产生能被 GNU 调试器GDB使用的调试信息，以调试程序。
# 产生带调试信息的可执行文件test
1
2

g++ -g test.cpp
1

2. -O[n] 优化源代码

## 所谓优化，例如省略掉代码中从未使用过的变量、直接将常量表达式用结果值代替等等，这些操作会缩减目标文件所包含的代码量，提高最终生成的可执行文件的运行效率。
# -O 选项告诉 g++ 对源代码进行基本优化。这些优化在大多数情况下都会使程序执行的更快。 -O2选项告诉 g++ 产生尽可能小和尽可能快的代码。 如-O2，-O3，-On（n 常为0–3）
# -O 同时减小代码的长度和执行时间，其效果等价于-O1
# -O0 表示不做优化
# -O1 为默认优化
# -O2 除了完成-O1的优化之外，还进行一些额外的调整工作，如指令调整等。
# -O3 则包括循环展开和其他一些与处理特性相关的优化工作。
# 选项将使编译的速度比使用 -O 时慢， 但通常产生的代码执行速度会更快。
# 使用 -O2优化源代码，并输出可执行文件

1
2
3
4
5
6
7
8
9
10

g++ -O2 test.cpp
1

3. -l 和 -L 指定库文件 | 指定库文件路径

# -l参数(小写)就是用来指定程序要链接的库，-l参数紧接着就是库名
# 在/lib和/usr/lib和/usr/local/lib里的库直接用-l参数就能链接
# 链接glog库
g++ -lglog test.cpp
# 如果库文件没放在上面三个目录里，需要使用-L参数(大写)指定库文件所在目录
# -L参数跟着的是库文件所在的目录名
# 链接mytest库，libmytest.so在/home/bing/mytestlibfolder目录下
1
2
3
4
5
6
7

++ -L/home/bing/mytestlibfolder -lmytest test.cpp
1

4. -I 指定头文件搜索目录

# -I
# /usr/include目录一般是不用指定的，gcc知道去那里找，但 是如果头文件不在/usr/icnclude
里我们就要用-I参数指定了，比如头文件放在/myinclude目录里，那编译命令行就要加上-
I/myinclude 参数了，如果不加你会得到一个”xxxx.h: No such file or directory”的错
误。-I参数可以用相对路径，比如头文件在当前 目录，可以用-I.来指定。上面我们提到的–cflags参
数就是用来生成-I参数的。
1
2
3
4
5
6

g++ -I/myinclude test.cpp
1

5. -Wall 打印警告信息

# 打印出gcc提供的警告信息
g++ -Wall test.cpp
1
2

6. -w 关闭警告信息

# 关闭所有警告信息
g++ -w test.cpp
1
2

7. -std=c++11 设置编译标准

# 使用 c++11 标准编译 test.cpp
g++ -std=c++11 test.cpp
1
2

8. -o 指定输出文件名

# 指定即将产生的文件名
# 指定输出可执行文件名为test
g++ test.cpp -o test
1
2
3

9. -D 定义宏

# 在使用gcc/g++编译的时候定义宏
# 常用场景：
# -DDEBUG 定义DEBUG宏，可能文件中有DEBUG宏部分的相关信息，用个DDEBUG来选择开启或关闭
DEBUG
1
2
3
4

// -Dname 定义宏name,默认定义内容为字符串“1”
#include 
int main()
{
#ifdef DEBUG
printf("DEBUG LOG\n");
#endif
printf("in\n");
}
1
2
3
4
5
6
7
8
9

// 1. 在编译的时候，使用g++ -DDEBUG main.cpp
// 2. printf(“DEBUG LOG\n”);可以被执行

注：使用 man gcc 命令可以查看gcc英文使用手册

实战g++命令行编译

案例：最初目录结构: 2 directories, 3 files
main函数调用swap交换函数，该函数头文件在include文件夹下，函数实现的源文件在src文件夹下。

直接编译

方法一：使用参数-I 指定头文件搜索路径include

# 将 main.cpp src/Swap.cpp 编译为可执行文件
g++ main.cpp src/Swap.cpp -Iinclude
# 运行a.out
./a.out
1
2
3
4

方法二：使用多个参数选项编译

# 将 main.cpp src/Swap.cpp 编译为可执行文件 附带一堆参数
g++ main.cpp src/Swap.cpp -Iinclude -std=c++11 -O2 -Wall -o b.out
# 运行 b.out
./b.out
1
2
3
4

动态库和静态库的区别

我们在使用c++封装为库，有两个平台：win(xxx.lib,静态；xxx.dll:动态库) 和 linux(xxx.a,静态；xxx.so:动态库)

静态库和动态库最本质的区别就是：该库是否被编译进目标（程序）内部。

• 静态（函数）库一般扩展名为（.a或.lib）,这类的函数库通常扩展名为libxxx.a或xxx.lib 。
  这类库在编译的时候会直接整合到目标程序中，所以利用静态函数库编译成的文件会比较大，这类函数库最大的优点就是编译成功的可执行文件可以独立运行，而不再需要向外部要求读取函数库的内容；但是从升级难易度来看明显没有优势，如果函数库更新，需要重新编译。
• 动态函数库的扩展名一般为（.so或.dll），这类函数库通常名为libxxx.so或xxx.dll 。
  与静态函数库被整个捕捉到程序中不同，动态函数库在编译的时候，在程序里只有一个“指向”的位置而已，也就是说当可执行文件需要使用到函数库的机制时，程序才会去读取函数库来使用；也就是说可执行文件无法单独运行。这样从产品功能升级角度方便升级，只要替换对应动态库即可，不必重新编译整个可执行文件。

从产品化的角度，发布的算法库或功能库尽量使动态库，这样方便更新和升级，不必重新编译整个可执行文件，只需新版本动态库替换掉旧动态库即可。

生成库文件并编译

编译为静态库

链接静态库生成可执行文件①：

## 进入src目录下
$cd src
# 汇编，生成Swap.o文件
g++ Swap.cpp -c -I../include
# 生成静态库libSwap.a
ar rs libSwap.a Swap.o
## 回到上级目录
$cd ..
# 链接，生成可执行文件:staticmain
g++ main.cpp -Iinclude -Lsrc -lSwap -o staticmain
1
2
3
4
5
6
7
8
9
10

静态库可以直接运行：

# 运行可执行文件
./staticmain
1
2

编译为动态库

链接动态库生成可执行文件②：

## 进入src目录下
$cd src
# 生成动态库libSwap.so
g++ Swap.cpp -I../include -fPIC -shared -o libSwap.so
## 上面命令等价于以下两条命令
# gcc Swap.cpp -I../include -c -fPIC
# gcc -shared -o libSwap.so Swap.o
## 回到上级目录
$cd ..
# 链接，生成可执行文件:sharemain
g++ main.cpp -Iinclude -Lsrc -lSwap -o sharemain
1
2
3
4
5
6
7
8
9
10
11

编译完成后的目录结构：

动态库不可以直接运行，需要指定库搜索路径：LD_LIBRARY_PATH=src 再在后边执行./sharemain
当然假如将动态库生成放在系统默认的库搜索路径中就可以直接执行。

# 运行可执行文件
LD_LIBRARY_PATH=src ./sharemain
1
2

GDB调试器

• GDB(GNU Debugger)是一个用来调试C/C++程序的功能强大的调试器，是Linux系统开发C/C++最常用的调试器
• 程序员可以使用GDB来跟踪程序中的错误，从而减少程序员的工作量。
• Linux 开发C/C++ 一定要熟悉 GDB
• VSCode是通过调用GDB调试器来实现C/C++的调试工作的；

GDB的主要功能

• 设置断点(断点可以是条件表达式)
• 使程序在指定的代码行上暂停执行，便于观察
• 单步执行程序，便于调试
• 查看程序中变量值的变化
• 动态改变程序的执行环境
• 分析崩溃程序产生的core文件

常用执行命令参数

注意:

1. 编译程序时需要加上-g，之后才能用gdb进行调试：gcc -g main.c -o main

2. 回车键：重复上一命令

调试开始：执行gdb [exefilename] ，进入gdb调试程序，其中exefilename为要调试的可执行文件名。

## 以下命令后括号内为命令的简化使用，比如run（r），直接输入命令 r 就代表run

$(gdb)help(h) # 查看命令帮助，具体命令查询在gdb中输入help + 命令
$(gdb)run(r) # 重新开始运行文件（run-text：加载文本文件，run-bin：加载二进制文
件）
$(gdb)start # 单步执行，运行程序，停在第一行执行语句
$(gdb)list(l) # 查看原代码（list-n,从第n行开始查看代码。list+ 函数名：查看具体函
数）
$(gdb)set # 设置变量的值
$(gdb)next(n) # 单步调试（逐过程，函数直接执行）
$(gdb)step(s) # 单步调试（逐语句：跳入自定义函数内部执行）
$(gdb)backtrace(bt) # 查看函数的调用的栈帧和层级关系
$(gdb)frame(f) # 切换函数的栈帧
$(gdb)info(i) # 查看函数内部局部变量的数值
$(gdb)finish # 结束当前函数，返回到函数调用点
$(gdb)continue(c) # 继续运行
$(gdb)print(p) # 打印值及地址
$(gdb)quit(q) # 退出gdb

$(gdb)break+num(b) # 在第num行设置断点
$(gdb)info breakpoints # 查看当前设置的所有断点
$(gdb)delete breakpoints num(d) # 删除第num个断点
$(gdb)display # 追踪查看具体变量值
$(gdb)undisplay # 取消追踪观察变量
$(gdb)watch # 被设置观察点的变量发生修改时，打印显示
$(gdb)i watch # 显示观察点
$(gdb)enable breakpoints # 启用断点
$(gdb)disable breakpoints # 禁用断点
$(gdb)x # 查看内存x/20xw 显示20个单元，16进制，4字节每单元
$(gdb)run argv[1] argv[2] # 调试时命令行传参
$(gdb)set follow-fork-mode child#Makefile项目管理：选择跟踪父子进程（fork()）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

命令行调试实战

针对下边这段代码：

#include 
using namespace std;
int main(int argc,char **argv)
{
int N = 100;
int sum = 0;
int i = 1;
// calculate sum from 1 to 100
while (i <= N)
{
sum = sum + i;
i = i + 1;
}
cout << "sum = " << sum << endl;
cout << "The program is over." << endl;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

IDE-VSCode

开发插件

以下三款插件是在Linux下开发C/C++的三款必备插件~

• C/C++
• CMake
• CMake Tools
  

快捷键

VSCode全部的快捷键：

高频快捷键

高频使用快捷键：

跳转

编辑器与窗口管理

代码编辑相关

• 格式调整

1. 代码行缩进 Ctrl+[ 、 Ctrl+]
2. Ctrl+C 、 Ctrl+V 复制或剪切当前行/当前选中内容
3. 代码格式化： Shift+Alt+I ，或 Ctrl+Shift+P 后输入 format code
4. 上下移动一行： Alt+Up 或 Alt+Down
5. 向上向下复制一行： Shift+Alt+Up 或 Shift+Alt+Down
6. 在当前行下边插入一行 Ctrl+Enter
7. 在当前行上方插入一行 Ctrl+Shift+Enter

• 光标相关

8. 移动到行首： Home
9. 移动到行尾： End
10. 移动到文件结尾： Ctrl+End
11. 移动到文件开头： Ctrl+Home
12. 移动到定义处： F12
13. 定义处缩略图：只看一眼而不跳转过去 Alt+F12
14. 移动到后半个括号： Ctrl+Shift+]
15. 选择从光标到行尾： Shift+End
16. 选择从行首到光标处： Shift+Home
17. 删除光标右侧的所有字： Ctrl+Delete
18. 扩展/缩小选取范围： Shift+Alt+Left 和 Shift+Alt+Right
19. 多行编辑(列编辑)： Alt+Shift+鼠标左键， Ctrl+Alt+Down/Up
20. 同时选中所有匹配： Ctrl+Shift+L
21. Ctrl+D 下一个匹配的也被选中 (在 sublime 中是删除当前行，后面自定义快键键中，设置与
    Ctrl+Shift+K 互换了)
22. 回退上一个光标操作： Ctrl+U

• 重构代码

1. 找到所有的引用： Shift+F12
2. 同时修改本文件中所有匹配的： Ctrl+F12
3. 重命名：比如要修改一个方法名，可以选中后按 F2 ，输入新的名字，回车，会发现所有的文件都
   修改了
4. 跳转到下一个 Error 或 Warning ：当有多个错误时可以按 F8 逐个跳转
5. 查看 diff ： 在 explorer 里选择文件右键 Set file to compare ，然后需要对比的文件上右
   键选择 Compare with file_name_you_chose

• 查找替换

1. 查找 Ctrl+F
2. 查找替换 Ctrl+H
3. 整个文件夹中查找 Ctrl+Shift+F

CMake

前言：
CMake是一个跨平台的安装编译工具，可以用简单的语句来描述所有平台的安装(编译过程)。
CMake可以说已经成为大部分C++开源项目标配

引入CMake的原因

假设有跨平台的C++项目：

假如要加一个bar.cpp源文件，你需要手动地把在多平台上进行更改的操作：

CMake就是为了解决上述的设计缺陷，我们可以使用CMakeList来描述我们的项目的跨平台情况，然后使用CMake来编译生成文件来替代跨平台软件：

有了CMake，假如要添加bar.cpp文件，就可以直接更改我们的CMakeList.txt后重构：

CMake语法特性

• 基本语法格式：指令(参数 1 参数 2…)
  • 参数使用括弧括起
  • 参数之间使用空格或分号分开
• 指令是大小写无关的，参数和变量是大小写相关的

set(HELLO hello.cpp)
add_executable(hello main.cpp hello.cpp)
ADD_EXECUTABLE(hello main.cpp ${HELLO})
1
2
3

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

重要指令和CMake常用变量

指令

cmake_minimum_required - 指定CMake的最小版本要求
语法： cmake_minimum_required(VERSION versionNumber [FATAL_ERROR])

# CMake最小版本要求为2.8.3
cmake_minimum_required(VERSION 2.8.3)
1
2

project - 定义工程名称，并可指定工程支持的语言
语法： project(projectname [CXX] [C] [Java])

# 指定工程名为HELLOWORLD
project(HELLOWORLD)
1
2

set - 显式的定义变量
语法：set(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])

# 定义SRC变量，其值为sayhello.cpp hello.cpp
set(SRC sayhello.cpp hello.cpp)
1
2

include_directories - 向工程添加多个特定的头文件搜索路径 —>相当于指定g++编译器的-I参数
语法： include_directories([AFTER|BEFORE] [SYSTEM] dir1 dir2 …)

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

link_directories - 向工程添加多个特定的库文件搜索路径 —>相当于指定g++编译器的-L参数
语法： link_directories(dir1 dir2 …)

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

add_library - 生成库文件
语法： add_library(libname [SHARED|STATIC|MODULE] [EXCLUDE_FROM_ALL]
source1 source2 … sourceN)

# 通过变量 SRC 生成 libhello.so 共享库
add_library(hello SHARED ${SRC})
1
2

add_compile_options - 添加编译参数
语法：add_compile_options()

# 添加编译参数 -Wall -std=c++11 -O2
add_compile_options(-Wall -std=c++11 -O2)
1
2

add_executable - 生成可执行文件
语法：add_executable(exename source1 source2 … sourceN)

# 编译main.cpp生成可执行文件main
add_executable(main main.cpp)
1
2

target_link_libraries - 为 target 添加需要链接的共享库 —>相同于指定g++编译器-l参数
语法： target_link_libraries(target library1 library2…)

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

add_subdirectory - 向当前工程添加存放源文件的子目录，并可以指定中间二进制和目标二进制
存放的位置
语法： add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

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

aux_source_directory - 发现一个目录下所有的源代码文件并将列表存储在一个变量中，这个指
令临时被用来自动构建源文件列表
语法： aux_source_directory(dir VARIABLE)

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

CMake常用变量

• CMAKE_C_FLAGS gcc编译选项
  CMAKE_CXX_FLAGS g++编译选项

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

• CMAKE_BUILD_TYPE 编译类型(Debug, Release)

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

• CMAKE_BINARY_DIR
• PROJECT_BINARY_DIR
• _BINARY_DIR

1. 这三个变量指代的内容是一致的。
2. 如果是 in source build，指的就是工程顶层目录。
3. 如果是 out-of-source 编译,指的是工程编译发生的目录。
4. PROJECT_BINARY_DIR 跟其他指令稍有区别，不过现在，你可以理解为他们是一致
   的

• CMAKE_SOURCE_DIR
• PROJECT_SOURCE_DIR
• _SOURCE_DIR

1. 这三个变量指代的内容是一致的,不论采用何种编译方式,都是工程顶层目录。
2. 也就是在 in source build时,他跟 CMAKE_BINARY_DIR 等变量一致。
3. PROJECT_SOURCE_DIR 跟其他指令稍有区别,现在,你可以理解为他们是一致的。
1
2
3

• CMAKE_C_COMPILER：指定C编译器
• CMAKE_CXX_COMPILER：指定C++编译器
• EXECUTABLE_OUTPUT_PATH：可执行文件输出的存放路径
• LIBRARY_OUTPUT_PATH：库文件输出的存放路径

CMake编译工程

CMake目录结构：项目主目录存在一个CMakeLists.txt文件
两种方式设置编译规则：

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

编译流程

在 linux 平台下使用 CMake 构建C/C++工程的流程如下:

1. 手动编写 CMakeLists.txt。
2. 执行命令 cmake PATH 生成 Makefile ( PATH 是顶层CMakeLists.txt 所在的目录 )。
3. 执行命令make 进行编译。

两种构建方式

内部构建

内部构建(in-source build)：不推荐使用
内部构建会在同级目录下产生一大堆中间文件，这些中间文件并不是我们最终所需要的，和工程源，文件放在一起会显得杂乱无章。

## 内部构建
# 在当前目录下，编译本目录的CMakeLists.txt，生成Makefile和其他文件
cmake .
# 执行make命令，生成target
make
1
2
3
4
5

外部构建

外部构建(out-of-source build)：推荐使用
将编译输出文件与源文件放到不同目录中

## 外部构建
# 1. 在当前目录下，创建build文件夹
mkdir build
# 2. 进入到build文件夹
cd build
# 3. 编译上级目录的CMakeLists.txt，生成Makefile和其他文件
cmake ..
# 4. 执行make命令，生成target
make
1
2
3
4
5
6
7
8
9