Linux下基于VSCode和CMake的C++开发和调试

1. 编译器、调试器安装

1.1 安装GCC， GDB

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

安装成功确认

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

1.2 CMake安装

# 通过以下命令安装编译器和调试器
sudo apt install cmake

安装成功确认

# 确认是否安装成功
# 如果成功，则显示版本号
cmake --version

2. GCC编译器

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

实际使用中：
使用 gcc 指令编译 C 代码；使用 g++指令编译 C++ 代码

2.1 编译过程

1. 预处理-Pre-Processing //.i文件

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

2. 编译-Compiling // .s文件

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

3. 汇编-Assembling // .o文件

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

4. 链接-Linking // bin文件

# -o 编译选项来为将产生的可执行文件用指定的文件名
g++ test.o -o test

2.2 g++重要编译参数

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

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

2. -O[n] 优化源代码
   -O 同时减小代码的长度和执行时间，其效果等价于-O1
   -O0 表示不做优化
   -O1 为默认优化
   -O2 除了完成-O1的优化之外，还进行一些额外的调整工作，如指令调整等。
   -O3 则包括循环展开和其他一些与处理特性相关的优化工作。
   选项将使编译的速度比使用 -O 时慢， 但通常产生的代码执行速度会更快

3. -l 和 -L 指定库文件 | 指定库文件路径
   -l参数(小写)就是用来指定程序要链接的库，-l参数紧接着就是库名
   在/lib和/usr/lib和/usr/local/lib里的库直接用-l参数就能链接
   如果库文件没放在上面三个目录里，需要使用-L参数(大写)指定库文件所在目录
   -L参数跟着的是库文件所在的目录名

# 链接mytest库，libmytest.so在/home/bing/mytestlibfolder目录下
g++ -L/home/bing/mytestlibfolder -lmytest test.cpp

4. -I 指定头文件搜索目录
   /usr/include目录一般是不用指定的，gcc知道去那里找，但 是如果头文件不在/usr/icnclude
   里我们就要用-I参数指定了，比如头文件放在/myinclude目录里，那编译命令行就要加上-
   I/myinclude 参数了

g++ -I/myinclude test.cpp

5. -Wall 打印警告信息
6. -w 关闭警告信息
7. -std=c++11 设置编译标准
8. -o 指定输出文件名
9. -D 定义宏

2.3 g++命令行编译

swap.h 在 include 文件中，swap.cpp 在 src 文件夹中，main.cpp在总文件中

直接编译

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

增加参数编译，并运行

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

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

## 进入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
# 运行可执行文件
./staticmain

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

## 进入src目录下
$cd src
# 生成动态库libSwap.so
g++ Swap.cpp -I../include -fPIC -shared -o libSwap.so
## 上面命令等价于以下两条命令，先生成目标文件，在生成动态库，用到-fPIC 和 -shared
# gcc Swap.cpp -I../include -c -fPIC
# gcc -shared -o libSwap.so Swap.o
## 回到上级目录
$cd ..
# 链接，生成可执行文件:sharemain
g++ main.cpp -Iinclude -Lsrc -lSwap -o sharemain
# 运行可执行文件
LD_LIBRARY_PATH=src ./sharemain

补充：静态库与动态库
静态库是在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。程序在运行时与函数库再无瓜葛，移植方便。浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。
动态库在程序编译时并不会被连接到目标代码中，而是在程序运行时才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行时才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可增量更新.

3. GDB调试器

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

GDB主要功能：

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

3.1 常用调试命令参数

调试开始：执行gdb [exefilename] ，进入gdb调试程序，其中exefilename为要调试的可执行文件名。编译程序时需要加上-g，之后才能用gdb进行调试：gcc -g main.c -o main

$(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()）

4. IDE - VSCode

4.1 安装

依次输入如下命令
1、 sudo add-apt-repository ppa:ubuntu-desktop/ubuntu-make
2、 sudo apt-get update
3、 sudo apt-get install ubuntu-make
4、 umake ide visual-studio-code
提示输入a即可

安装完成后，reboot重启系统。使用命令visual-studio-code可以打开vscode界面，如果不行，尝试先cd到安装目录下 cd /home/wen/.local/share/umake/ide/visual-studio-code/ 运行 ./code

在Linux终端中，cd到工作目录中，然后输入visual-studio-code .就在当前目录下打开了VScode

3.2 安装插件

以下三款插件是在Linux下开发C/C++的三款必备插件
C/C++；CMake；CMake Tools
在vscode界面侧边栏Extensions中进行安装

3.3 快捷键

快捷键：编辑器与窗口管理

1. 打开一个新窗口： Ctrl+Shift+N
2. 关闭窗口： Ctrl+Shift+W
3. 同时打开多个编辑器（查看多个文件）
4. 新建文件 Ctrl+N
5. 文件之间切换 Ctrl+Tab
6. 切出一个新的编辑器（最多 3 个） Ctrl+\ ，也可以按住 Ctrl 鼠标点击 Explorer 里的文件名
7. 左中右 3 个编辑器的快捷键 Ctrl+1 Ctrl+2 Ctrl+3
8. 3 个编辑器之间循环切换 Ctrl+
9. 编辑器换位置， Ctrl+k 然后按 Left 或 Right

快捷键：格式调整
10. 代码行缩进 Ctrl+[ 、 Ctrl+]
11. Ctrl+C 、 Ctrl+V 复制或剪切当前行/当前选中内容
12. 代码格式化： Shift+Alt+F ，或 Ctrl+Shift+P 后输入 format code
13. 上下移动一行： Alt+Up 或 Alt+Down
14. 向上向下复制一行： Shift+Alt+Up 或 Shift+Alt+Down
15. 在当前行下边插入一行 Ctrl+Enter
16. 在当前行上方插入一行 Ctrl+Shift+Enter

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

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

快捷键：查找替换
37. 查找 Ctrl+F
38. 查找替换 Ctrl+H
39. 整个文件夹中查找 Ctrl+Shift+F

快捷键：显示相关
40. 全屏： F11
41. zoomIn/zoomOut： Ctrl +/-
42. 侧边栏显/隐： Ctrl+B
43. 显示资源管理器 Ctrl+Shift+E
44. 显示搜索 Ctrl+Shift+F
45. 显示 Git Ctrl+Shift+G
46. 显示 Debug Ctrl+Shift+D
47. 显示 Output Ctrl+Shift+U

5. CMake

CMake是一个跨平台的安装编译工具，可以用简单的语句来描述所有平台的安装(编译过程)。

语法特性介绍
基本语法格式：指令(参数 1 参数 2…)
参数使用括弧括起；参数之间使用空格或分号分开；指令是大小写无关的，参数和变量是大小写相关的
变量使用${}方式取值，但是在 IF 控制语句中是直接使用变量名

5.1 重要指令和CMake常用变量

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

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

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

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

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

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

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

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

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

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

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

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

add_compile_options - 添加编译参数

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

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

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

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

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

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

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

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

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

CMake常用变量
CMAKE_C_FLAGS gcc编译选项
CMAKE_CXX_FLAGS g++编译选项
CMAKE_BUILD_TYPE 编译类型(Debug, Release)，例如 set(CMAKE_BUILD_TYPE Debug)
CMAKE_BINARY_DIR 如果是 in source build，指的就是工程顶层目录； 如果是 out-of-source 编译,指的是工程编译发生的目录
CMAKE_SOURCE_DIR 工程顶层目录
CMAKE_C_COMPILER：指定C编译器
CMAKE_CXX_COMPILER：指定C++编译器
EXECUTABLE_OUTPUT_PATH：可执行文件输出的存放路径
LIBRARY_OUTPUT_PATH：库文件输出的存放路径

5.2 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

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

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

5.3 CMake代码实践

swap.h 包含在 include 文件夹中，swap.cpp 包含在 src 文件夹中， 主文件 main.cpp
首先创建CMakeLists.txt文件，输入下面代码

cmake_minimum_required(VERSION 3.0)

project(SWAP)

include_directories(include)

add_executable(main_cmake main.cpp src/swap.cpp)

在终端创建build文件夹，执行外部构建的四条命令。

6. 使用VSCode进行完整项目开发

案例：士兵突击
需求：

1. 士兵 许三多 有一把枪，叫做 AK47
2. 士兵 可以 开火
3. 士兵 可以 给枪装填子弹
4. 枪 能够 发射 子弹
5. 枪 能够 装填子弹 —— 增加子弹数量
   开发：
   开发枪类
   开发士兵类

#pragma once
#include <string>

class Gun
{
public:
    Gun(std::string type){
        this->_type = type;
        this->_bullet_count = 0;
    }

    void addBullet(int bullet_num);
    bool shoot();

private:
    int _bullet_count;
    std::string _type;

};

#include "Gun.h"
#include <iostream>

void Gun::addBullet(int bullet_num)
{
    this->_bullet_count += bullet_num;
}

bool Gun::shoot()
{
    if (this->_bullet_count <= 0)
    {
        std::cout << "There is no bullet!" << std::endl;
        return false;
    }
    std::cout << "shoot successfully!" << std::endl;
    this->_bullet_count -= 1;
    return false;
}

#pragma once
#include "Gun.h"
#include <string>

class Solider
{
private:
    /* data */
    std::string _name;
    Gun* _ptr_gun;
public:
    Solider(std::string name);
    void addBulletToGun(int nums);
    bool fire();
    void addGun(Gun* ptr_gun);
    ~Solider();
};

#include "Solider.h"

Solider::Solider(std::string name)
{
    this->_name = name;
    this->_ptr_gun = nullptr;
}

void Solider::addGun(Gun* ptr_gun)
{
    this->_ptr_gun = ptr_gun;
}

void Solider::addBulletToGun(int num)
{
    this->_ptr_gun->addBullet(num);
}

bool Solider::fire()
{
   return this->_ptr_gun->shoot();
}

Solider::~Solider()
{
    if (this->_ptr_gun == nullptr)
        return;
    delete this->_ptr_gun;
    this->_ptr_gun = nullptr;
}

#include "Gun.h"
#include "Solider.h"
#include <iostream>

void test()
{
    Solider sanduo("xusanduo");
    sanduo.addGun(new Gun("AK47"));
    sanduo.addBulletToGun(20);
    sanduo.fire();
}

int main(int argc, char** argv)
{
    std::cout << "This is a test string..." << std::endl;
    test();
    return 0;
}

使用g++进行编译
终端输入命令：g++ main.cpp src/Gun.cpp src/Solider.cpp -Iinclude -std=c++11 -o myexe

使用CMake编译
CMakeLists.txt文件

cmake_minimum_required(VERSION 3.0)

project(SOLIDERFIRE)

include_directories(include)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -O2 -std=c++11")

add_executable(my_cmake_exe main.cpp src/Gun.cpp src/Solider.cpp)

使用外部构建，手动编译CMake项目

配置VSCode的json文件并调试项目
点击VSCode左侧Run按钮，点击create a launch.json File，选择C++(GDB/LLDB)，选择g++生成和调试活动文件，便生成了launch.json文件，里面有两个重要参数：program和preLaunchTask，program表示要调试文件的绝对路径，
“program”: “${workspaceFolder}/build/my_cmake_exe”,
workspaceFolder表示项目的顶层文件夹

在main文件中添加断点，按F5进行调试

打开preLaunchTask，点击Terminal，点击Configure Default Built Task，点击Create tasks.json file from template，创建tasks.json文件

launch.json文件中"preLaunchTask": "Build"的Build与tasks.json 文件中的Build对应，表示在调试之前要执行Build定义的操作，即cmake和make。通过这种方式，每次调试的时候都会编译文件并调试，如果不用preLaunchTasks，则调试的内容为编译好的可执行文件。

launch.json文件

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/build/my_cmake_exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "Build",
            "miDebuggerPath": "/usr/bin/gdb"
        }
    ]
}

tasks.json文件，要写3个任务，分别是执行cmake任务，make任务，和当前执行的build任务。

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "options": {
        "cwd":"${workspaceFolder}/build"
    },
    "tasks": [
        {
            "label": "cmake",
            "type": "shell",
            "command": "cmake",
            "args":[
                ".."
            ]
        },
        {
            "label":"make",
            "group":{
                "kind": "build",
                "isDefault": true
            },
            "command":"make",
            "args": [

            ]
        },
        {
            "label":"Build",
            "dependsOrder": "sequence",
            "dependsOn":[
                "cmake",
                "make"
            ]
        }
    ]
}