博客

LINUX下g++/gcc&CMake使用笔记/搭配VSCODE

  • Post author:
  • Post category:linux



Author:Peter



Location:FZU



Date: 2022-3-21


：授人以鱼不如授人以渔。

了解C/C++底层编译原理后，利用Cmake工具构建自己的工程，便于跨平台开发。

文章目录



一、gcc/g++使用



1.gcc/g++ 常用编译参数

参数 功能
-g 编译带调试信息的可执行文件（可用于GDB断点调试）
-O[n] n∈[0,3],一般为-O2 编译器优化源代码，提升代码运行效率
–

I
 		指定头文件位置
–

L
 		指定链接库位置
–

l
 		指定链接名，如调用libsrt.so，则-lsrt
-Wall 打印warning信息
-w 关闭warning信息
-std=c++11 设置编译标准为c11
-c 只编译不链接,生成同名.o文件
-o 指定输出文件名
–

D
 		定义宏，如-D Debug=1，则源程序中相应Debug宏开关置1



2. 工程目录结构

.
├── include
│   ├── sort.h
│   └── swap.h
├── main.cpp
└── src
    ├── sort.cpp
    └── swap.cpp

2 directories, 5 files

/*-----------swap.h--------------*/
#pragma once
#ifndef __SWAP_H__
#define __SWAP_H__

#include <iostream>

void mySwap(int &a, int &b);

#endif

/*-----------swap.cpp--------------*/
#include "swap.h"

void mySwap(int &a,int&b)
{
#ifdef Debug
    std::cout<<"Debug"<<std::endl;
#endif
    int temp = a;
    a = b;
    b = temp;
}

/*-----------sort.h--------------*/
#pragma once
#ifndef __SORT_H__
#define __SORT_H__

#include <iostream>
#include <set>

template <class T>
class myCompare
{
public:
    inline bool operator()(const T &a, const T &b) const
    {
        return a > b;
    }
};

// 冒泡排序从大到小
void mySortSet(int arr[], int arrSize);

// 模板函数需要定义在.h中，不能与声明分开为两个模块
template <class T>
void myTmpSortSet(T arr[], int arrSize)
{
    std::set<T, myCompare<T>> setNumLargeToSmall;
    for (int i = 0; i < arrSize; ++i)
    {
        setNumLargeToSmall.insert(arr[i]);
    }

    int j = 0;
    for (auto iter = setNumLargeToSmall.begin(); iter != setNumLargeToSmall.end(); ++iter)
    {
        arr[j] = *iter;
        ++j;
    }
}

#endif

/*-----------sort.cpp--------------*/
#include "sort.h"

void mySortSet(int arr[], int arrSize)
{
    bool b_swap = true; // 标志位，记录每次排序是否有元素位置交换
    int count = arrSize - 1;
    for (int i = 0; i < count && b_swap; ++i) // 如果上次排序元素位置未改变，则排序完成。
    {
        b_swap = false; // 每次排序前，标志位复位
        for (int j = 0; j < count - i; ++j)
        {
            if (arr[j] < arr[j + 1])  //若要从小到大，则arr[j]>arr[j+1]，把小的放在最前头
            {
                b_swap = true; //发生位置交换，标志位置位
                int tmp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

/*-----------main.cpp--------------*/
#include "swap.h"
#include "sort.h"
#include <algorithm>
#include <functional>

template <class T>
void printArray(T arr[], const int &arrSize)
{
    for (int i = 0; i < arrSize; ++i)
        std::cout << arr[i] << " ";
}

void countNum(int arr[], const int &arrSize, const int &n)
{
    //统计不大于等于n的数，即小于n的数
    std::cout << std::count_if(arr, arr + arrSize, std::not1(std::bind2nd(std::greater_equal<int>(), n))) << "\n";
    // bind std::placeholders::_1(占位符，占1位，_2占两位) <==> a  n<==> b
    // 统计比n大的数
    std::cout << std::count_if(arr, arr + arrSize, std::bind(myCompare<int>(), std::placeholders::_1, n)) << "\n";
    // lambda 统计大于-n小于n的数，注意[&]捕捉外部参数变量n，以引用方式传递，[=]值传递
    std::cout << std::count_if(arr, arr + arrSize, [&](int x){ return x > -n && x < n; })
              << "\n";
}

int main(int argc, char **argv)
{
    int a = 10, b = 15;
    mySwap(a, b);
    std::cout << a << "\t" << b << std::endl;

    int arr1[] = {1, 3, 2, 5, 4};
    int arr1_size = sizeof(arr1) / sizeof(int);

    double arr2[] = {10.289, 31.34, 3.22, 7.05, 4, 9.8};
    int arr2_size = sizeof(arr2) / sizeof(double);

    mySortSet(arr1, arr1_size);
    myTmpSortSet(arr2, arr2_size);

    std::cout << "arr1: ";
    printArray(arr1, arr1_size);

    std::cout << "\n"
              << "arr2: ";
    printArray(arr2, arr2_size);

    std::cout << "\n";

    countNum(arr1, arr1_size, 4);

    return 0;
}



3. 直接编译

#其实是由汇编main.o swap.o，sort.o文件生成二进制可执行文件test
g++ -O2 -std=c++11 main.cpp src/swap.cpp src/sort.cpp -D Debug -I include/ -o test
#运行二进制文件test
./test
Debug
15      10
arr1: 5 4 3 2 1 
arr2: 31.34 10.289 9.8 7.05 4 3.22
3
1
3



4. 生成库文件编译



4.1 静态编译（生成的可执行文件大，可直接使用）

#进入src目录
cd src
#汇编、将swap.cpp编译成swap.o  ../返回上级目录,由于Debug宏在swap.cpp中，固需在此-D Debug=1
g++ swap.cpp -D Debug=1 -c -I ../include
g++ sort.cpp -c -I ../include
#生成静态链接库libswap.a
ar rs libswso.a swap.o sort.o
#回到上级目录
cd ..
#链接，生成可执行文件test
g++ main.cpp -O2 -I include/ -L src/ -lswso -o test

#编译后
.
├── include
│   ├── sort.h
│   └── swap.h
├── main.cpp
├── src
│   ├── libswso.a
│   ├── sort.cpp
│   ├── sort.o
│   ├── swap.cpp
│   └── swap.o
└── test

2 directories, 9 files
#运行./test
Debug
15      10
arr1: 5 4 3 2 1 
arr2: 31.34 10.289 9.8 7.05 4 3.22
3
1
3



4.2 动态编译（编译生成的可执行文件小，执行时需将调用的动态链接库放置到/usr/lib下，或利用LD_LIBRARY_PATH指定动态链接库位置）


动态编译生成的二进制可执行文件可采用

readelf fileName -a |grep .so

指令或者

ldd

来查看绑定的动态链接库

。

[Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]

0x0000000000000001 (NEEDED) 共享库：[libswso_1.0.0.so]

0x0000000000000001 (NEEDED) 共享库：[libstdc++.so.6]

0x0000000000000001 (NEEDED) 共享库：[libgcc_s.so.1]

0x0000000000000001 (NEEDED) 共享库：[libc.so.6]


  • 详细流程
     
#进入src目录
cd src
#生成动态链接库libswap.so
g++ swap.cpp -D Debug=1 sort.cpp -I ../include -fPIC -shared -o libswso.so
#上面命令等于如下两条
#g++ swap.cpp -D Debug=1 sort.cpp -I ../include -c -fPIC
#g++ -shared -o libswso.so swap.o sort.o
#返回上级目录
cd ..
# 链接，生成可执行文件test
g++ main.cpp -O2 -I include/ -L src/ -lswso -o test
#编译后
.
├── include
│   ├── sort.h
│   └── swap.h
├── main.cpp
├── src
│   ├── libswso.a
│   ├── libswso.so
│   ├── sort.cpp
│   └── swap.cpp
└── test

2 directories, 8 files
#运行./test
报错error
./test: error while loading shared libraries: libswap.so: cannot open shared object file: No such file or directory

#解决方案
①将libswap.so拷贝至/usr/lib
#利用LD_LIBRARY_PATH指定libswap.so位置后再执行test文件
②export LD_LIBRARY_PATH=src ./test

#运行结果
Debug
15      10
arr1: 5 4 3 2 1 
arr2: 31.34 10.289 9.8 7.05 4 3.22
3
1
3



二、CMake使用



1、CMake基本语法

  • 基本语法格式：指令（参数1 参数2 …）各参数用分号或者空格隔开
  • 指令大小写无关，参数和变量大小写相关

    add_executable(test main.cpp swap.cpp sort.cpp)
等价于
ADD_EXECUTABLE(test main.cpp swap.cpp sort.cpp)



2、CMake重要指令


  • cmake_minimum_required

    指定CMake最小版本要求

    cmake_minimum_required(VERSION 2.8.3)

  • project

    定义工程名称，并可指定工程支持的语言

    //语法：project(projectName[CXX][C][JAVA])
project(HELLO_FZU)

  • set

    显示定义变量

    //语法：set(VAR [VALUE][CACHE TYPE DOCSTRING[FORCE]])
set(SRC swap.cpp sort.cpp) //定义SRC变量，值为swap.cpp sort.cpp

  • include_directories

    向工程添加多个头文件搜索路径

    //语法：include_directories([AFTER][BEFORE][SYSTEM]dir1 dir2 ...)
include_directories(/usr/include/fzuHeader /swap/include)//添加了两个include文件夹

  • link_directories

    向工程添加多个链接库文件搜索路径

    //语法：include_directories(dir1 dir2 ...)
link_directories(/usr/lib/fzuLib /swap/lib)//添加了两个lib文件夹

  • add_library

    生成库文件

    //语法：add_library(libname [SHARED|STATIC|MODULE]source1 source2 ... sourceN)
add_library(swso SHARED ${SRC})//利用SRC变量生成动态链接库libswap.so
add_library(swso STATIC ${SRC})//利用SRC变量生成静态链接库libswap.a

  • add_compile_options

    添加编译参数

    //语法：add_compile_options(<option> ...)
add_compile_options(-Wall -std=c++11 -O2 -D DNAME )//以C11标准编译，开启warning警告，编译器优化，定义DNAME宏

  • add_definitions

    添加编译参数

    add_definitions("-D HEAVY_DEBUG")

  • add_executable

    生成可执行文件

    //语法：add_executable(main main.cpp)
add_executable(main main.cpp)//编译main.cpp生成二进制可执行文件main

  • target_link_libraries

    为target添加需要链接的共享库等同于g++ -l

    //语法：target_link_libraries(target library1<debug | optimized> library2)
target_link_libraries(main swso)//把生成的libswap.so链接到可执行程序main

  • add_subdirectory

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

    //语法：add_subdirectory(source_dir [binary_dir][EXCLUDE_FROM_ALL])
add_subdirectory(src)//添加sc子目录，src中有一个CMakeLists.txt

  • aux_source_directory

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

    //语法：add_source_directory(dir VARIABLE)
add_source_directory(. SRC)//定义SRC变量，其值为当前目录下所有的源代码文件
add_executable(main ${SRC})//编译SRC变量所代表的源代码文件，生成二进制可执行文件main



3、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")


  • CMAKE_BUILD_TYPE

    编译类型(Debug,Release) 

    //调试时需要选择Debug
set(CMAKE_BUILD_TYPE Debug)
//发布时需要选择Release
set(CMAKE_BUILD_TYPE Release)


  • CMAKE_C_FLAGS_DEBUG

    CMAKE_BUILD_TYPE为Debug模式时调用


  • CMAKE_CXX_FLAGS_DEBUG


  • CMAKE_C_FLAGS_RELEASE

    CMAKE_BUILD_TYPE为Debug模式时调用


  • CMAKE_CXX_FLAGS_RELEASE


  • CMAKE_BINARY_DIR



    PROJECT_BINARY_DIR


    <projectname>

    _BINARY_DIR


    三者变量指代的内容一致。

    如果是in source build，指的就是工程顶层目录

    如果是out of source，指的是工程编译发生的目录


    运行cmake命令的目录，即工程编译发生的路径


  • CMAKE_SOURCE_DIR



    PROJECT_SOURCE_DIR


    <projectname>

    _SOURCE_DIR


    三者变量指代的内容一致，无论采用何种编译方式，都是工程顶层目录。

    也就是在in source build时，他跟CMAKE_BINARY_DIR变量一致


    包含PROJECT()命令的最近一个CMakeLists.txt文件所在的文件夹路径。


  • CMAKE_C_COMPILER

    指定gcc编译器


  • CMAKE_CXX_COMPILER

    指定g++编译器


  • EXECUTABLE_OUTPUT_PATH

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


  • LIBRARY_OUTPUT_PATH

    链接库文件输出的存放路径



4、利用CMake编译工程

CMake目录结构：项目主目录(顶层目录)存在CMakeLists.txt文件


两种方式设置编译规则：

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

    如SRT工程

    。



4.1 CMake编译流程

  1. 手动编写CMakeLists.txt
  2. 执行命令cmake PATH 生成MakeFile(

    PATH是顶层CMakeLists.txt所在目录

    )
  3. 执行命令make进行编译 
#文件位置
.     #当前目录
./    #当前目录

..    #上级目录
../   #上级目录



4.2 两种构建方式


1. 内部构建（in-source build）

：不推荐使用

内部构建会在同级目录下产生一大堆中间文件，如.o文件，这些中间文件并不是我们最终所需要的，和工程源文件放在一起会显得杂乱无章。 

#内部构建：

# 在当前目录下，编译本目录的CMakeLists.txt，生成Makefile和其他文件
cmake .

# 执行make命令，生成target
make


2. 外部构建（out-of-source build）

：推荐使用

将编译生成的中间文件放置指定目录，与源文件分割开。以下例子是进入build文件夹编译，则中间件都存在build目录下。 

#外部构建：

# 在当前目录下，创建build文件夹，目的将生成的中间文件存到build目录
mkdir build

# 进入build文件夹
cd build

# 编译上级目录的CMakeLists.txt，生成Makefile和其他文件
cmake ..

# 执行make命令，生成target
make



4.3 多目录CMake工程编写CMakeLists.txt（外部构建法）



4.3.1 只有顶层目录拥有一个CMakeLists.txt情况

  • 工程目录
     
#工程目录
.
├── build
├── CMakeLists.txt
├── include
│   ├── sort.h
│   └── swap.h
├── main.cpp
└── src
    ├── sort.cpp
    └── swap.cpp

3 directories, 6 files

  • CMakeLists.txt内容

    （

    此文本作用与g++直接编译效果相同

    ） 
#指定CMAKE最低版本号
cmake_minimum_required(VERSION 3.10.2)
#工程名为SWSO
project(SWSO)
#设置编译模式Debug/Release
set(CMAKE_BUILD_TYPE Debug)
#配置DEBUG模式 编译参数
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -O0 -Wall -g  -D Debug")
#配置RELEASE模式 编译参数
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O2 -Wall")
#配置可执行文件输出存放路径
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin)
#配置生成链接库输出存放路径
set(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/lib)
#指定额外头文件路径，相对路径
include_directories(${CMAKE_SOURCE_DIR}/include)
#添加编译参数
add_compile_options(-std=c++11)
#添加源文件到变量SRC
aux_source_directory(${CMAKE_SOURCE_DIR}/src/. SRC)
#生成链接库文件
add_library(swso SHARED ${SRC})
add_library(static_swso STATIC ${SRC})
#配置生成链接库版本号
set_target_properties(swso PROPERTIES OUTPUT_NAME "swso_1.0.0")
set_target_properties(static_swso PROPERTIES OUTPUT_NAME "static_swso_1.0.0")
#生成二进制可执行文件SWSO
add_executable(SWSO main.cpp)
#把生成的动态链接库libswso.so链接到可执行程序
target_link_libraries(SWSO swso)

  • 详细运行流程
     
# 进入build文件夹
cd build

# 编译上级目录的CMakeLists.txt，生成Makefile和其他文件
cmake ..

#运行效果如下:
-- The C compiler identification is GNU 7.5.0
-- The CXX compiler identification is GNU 7.5.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/peter/VS_CODE_PRO/RTSP_SERVER/build

# 执行make命令，生成target
make

#运行效果如下:
Scanning dependencies of target swso
[ 12%] Building CXX object CMakeFiles/swso.dir/src/sort.cpp.o
[ 25%] Building CXX object CMakeFiles/swso.dir/src/swap.cpp.o
[ 37%] Linking CXX shared library ../lib/libswso_1.0.0.so
[ 37%] Built target swso
Scanning dependencies of target SWSO
[ 50%] Building CXX object CMakeFiles/SWSO.dir/main.cpp.o
[ 62%] Linking CXX executable ../bin/SWSO
[ 62%] Built target SWSO
Scanning dependencies of target static_swso
[ 75%] Building CXX object CMakeFiles/static_swso.dir/src/sort.cpp.o
[ 87%] Building CXX object CMakeFiles/static_swso.dir/src/swap.cpp.o
[100%] Linking CXX static library ../lib/libstatic_swso_1.0.0.a
[100%] Built target static_swso

#编译完后的目录
.
├── bin
│   └── SWSO
├── build
│   ├── CMakeCache.txt
│   ├── CMakeFiles
│   │   ├── 3.10.2
│   │   │   ├── CMakeCCompiler.cmake
│   │   │   ├── CMakeCXXCompiler.cmake
│   │   │   ├── CMakeDetermineCompilerABI_C.bin
│   │   │   ├── CMakeDetermineCompilerABI_CXX.bin
│   │   │   ├── CMakeSystem.cmake
│   │   │   ├── CompilerIdC
│   │   │   │   ├── a.out
│   │   │   │   ├── CMakeCCompilerId.c
│   │   │   │   └── tmp
│   │   │   └── CompilerIdCXX
│   │   │       ├── a.out
│   │   │       ├── CMakeCXXCompilerId.cpp
│   │   │       └── tmp
│   │   ├── cmake.check_cache
│   │   ├── CMakeDirectoryInformation.cmake
│   │   ├── CMakeOutput.log
│   │   ├── CMakeTmp
│   │   ├── feature_tests.bin
│   │   ├── feature_tests.c
│   │   ├── feature_tests.cxx
│   │   ├── Makefile2
│   │   ├── Makefile.cmake
│   │   ├── progress.marks
│   │   ├── static_swso.dir
│   │   │   ├── build.make
│   │   │   ├── cmake_clean.cmake
│   │   │   ├── cmake_clean_target.cmake
│   │   │   ├── CXX.includecache
│   │   │   ├── DependInfo.cmake
│   │   │   ├── depend.internal
│   │   │   ├── depend.make
│   │   │   ├── flags.make
│   │   │   ├── link.txt
│   │   │   ├── progress.make
│   │   │   └── src
│   │   │       ├── sort.cpp.o
│   │   │       └── swap.cpp.o
│   │   ├── swso.dir
│   │   │   ├── build.make
│   │   │   ├── cmake_clean.cmake
│   │   │   ├── CXX.includecache
│   │   │   ├── DependInfo.cmake
│   │   │   ├── depend.internal
│   │   │   ├── depend.make
│   │   │   ├── flags.make
│   │   │   ├── link.txt
│   │   │   ├── progress.make
│   │   │   └── src
│   │   │       ├── sort.cpp.o
│   │   │       └── swap.cpp.o
│   │   ├── SWSO.dir
│   │   │   ├── build.make
│   │   │   ├── cmake_clean.cmake
│   │   │   ├── CXX.includecache
│   │   │   ├── DependInfo.cmake
│   │   │   ├── depend.internal
│   │   │   ├── depend.make
│   │   │   ├── flags.make
│   │   │   ├── link.txt
│   │   │   ├── main.cpp.o
│   │   │   └── progress.make
│   │   └── TargetDirectories.txt
│   ├── cmake_install.cmake
│   └── Makefile
├── CMakeLists.txt
├── include
│   ├── sort.h
│   └── swap.h
├── lib
│   ├── libstatic_swso_1.0.0.a
│   └── libswso_1.0.0.so
├── main.cpp
└── src
    ├── sort.cpp
    └── swap.cpp

17 directories, 64 files


#运行编译生成的二进制可执行文件./bin/SWSO
Debug
15      10
arr1: 5 4 3 2 1 
arr2: 31.34 10.289 9.8 7.05 4 3.22
3
1
3


4.3.2 子目录中也含有CMakeLists.txt情况

  • 工程目录
     
#工程目录
.
├── build
├── CMakeLists.txt
├── include
│   ├── sort.h
│   └── swap.h
├── main.cpp
└── src
    ├── CMakeLists.txt
    ├── sort.cpp
    └── swap.cpp

2 directories, 7 files

  • 子目录下CMakeLists.txt内容
     
#指定CMAKE最低版本号
cmake_minimum_required(VERSION 3.10.2)
#工程名为SWSO
project(SWSO)
#设置编译模式Debug/Release
set(CMAKE_BUILD_TYPE Debug)
#配置DEBUG模式 编译参数
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -O0 -Wall -g")
#配置RELEASE模式 编译参数
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O2 -Wall")
#配置生成链接库输出存放路径
set(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/lib)
#指定额外头文件路径，相对路径
include_directories(${CMAKE_SOURCE_DIR}/include)
#添加编译参数
add_compile_options(-std=c++11)
#设置swap.cpp中的宏开关Debug
add_definitions(-D Debug)
#添加源文件到变量SRC
aux_source_directory(${CMAKE_SOURCE_DIR}/src/. SRC)
#生成链接库文件
add_library(swso SHARED ${SRC})
add_library(static_swso STATIC ${SRC})
#配置生成链接库版本号
set_target_properties(swso PROPERTIES OUTPUT_NAME "swso_1.0.0")
set_target_properties(static_swso PROPERTIES OUTPUT_NAME "static_swso_1.0.0")

  • 顶层CMakeLists.txt内容
     
#指定CMAKE最低版本号
cmake_minimum_required(VERSION 3.10.2)
#工程名为SWSO
project(SWSO)
#设置编译模式Debug/Release
set(CMAKE_BUILD_TYPE Debug)
#配置DEBUG模式 编译参数
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -O0 -Wall -g")
#配置RELEASE模式 编译参数
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O2 -Wall")
#配置可执行文件输出存放路径
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin)
#指定额外头文件路径，相对路径
include_directories(${CMAKE_SOURCE_DIR}/include)
#添加编译参数
add_compile_options(-std=c++11)
#添加子目录CMakeLists.txt
add_subdirectory(${CMAKE_SOURCE_DIR}/src)
#生成二进制可执行文件SWSO
add_executable(SWSO main.cpp)
#把生成的动态链接库libswso.so链接到可执行程序
target_link_libraries(SWSO swso)

  • 详细运行流程
     
# 进入build文件夹
cd build

# 编译上级目录的CMakeLists.txt，生成Makefile和其他文件
cmake ..

#运行效果如下:
-- The C compiler identification is GNU 7.5.0
-- The CXX compiler identification is GNU 7.5.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/peter/VS_CODE_PRO/TEST/build

# 执行make命令，生成target
make

#运行效果如下:
Scanning dependencies of target swso
[ 12%] Building CXX object src/CMakeFiles/swso.dir/sort.cpp.o
[ 25%] Building CXX object src/CMakeFiles/swso.dir/swap.cpp.o
[ 37%] Linking CXX shared library ../../lib/libswso_1.0.0.so
[ 37%] Built target swso
Scanning dependencies of target SWSO
[ 50%] Building CXX object CMakeFiles/SWSO.dir/main.cpp.o
[ 62%] Linking CXX executable ../bin/SWSO
[ 62%] Built target SWSO
Scanning dependencies of target static_swso
[ 75%] Building CXX object src/CMakeFiles/static_swso.dir/sort.cpp.o
[ 87%] Building CXX object src/CMakeFiles/static_swso.dir/swap.cpp.o
[100%] Linking CXX static library ../../lib/libstatic_swso_1.0.0.a
[100%] Built target static_swso

#编译完后的目录
.
├── bin
│   └── SWSO
├── build
│   ├── CMakeCache.txt
│   ├── CMakeFiles
│   │   ├── 3.10.2
│   │   │   ├── CMakeCCompiler.cmake
│   │   │   ├── CMakeCXXCompiler.cmake
│   │   │   ├── CMakeDetermineCompilerABI_C.bin
│   │   │   ├── CMakeDetermineCompilerABI_CXX.bin
│   │   │   ├── CMakeSystem.cmake
│   │   │   ├── CompilerIdC
│   │   │   │   ├── a.out
│   │   │   │   ├── CMakeCCompilerId.c
│   │   │   │   └── tmp
│   │   │   └── CompilerIdCXX
│   │   │       ├── a.out
│   │   │       ├── CMakeCXXCompilerId.cpp
│   │   │       └── tmp
│   │   ├── cmake.check_cache
│   │   ├── CMakeDirectoryInformation.cmake
│   │   ├── CMakeOutput.log
│   │   ├── CMakeTmp
│   │   ├── feature_tests.bin
│   │   ├── feature_tests.c
│   │   ├── feature_tests.cxx
│   │   ├── Makefile2
│   │   ├── Makefile.cmake
│   │   ├── progress.marks
│   │   ├── SWSO.dir
│   │   │   ├── build.make
│   │   │   ├── cmake_clean.cmake
│   │   │   ├── CXX.includecache
│   │   │   ├── DependInfo.cmake
│   │   │   ├── depend.internal
│   │   │   ├── depend.make
│   │   │   ├── flags.make
│   │   │   ├── link.txt
│   │   │   ├── main.cpp.o
│   │   │   └── progress.make
│   │   └── TargetDirectories.txt
│   ├── cmake_install.cmake
│   ├── Makefile
│   └── src
│       ├── CMakeFiles
│       │   ├── CMakeDirectoryInformation.cmake
│       │   ├── progress.marks
│       │   ├── static_swso.dir
│       │   │   ├── build.make
│       │   │   ├── cmake_clean.cmake
│       │   │   ├── cmake_clean_target.cmake
│       │   │   ├── CXX.includecache
│       │   │   ├── DependInfo.cmake
│       │   │   ├── depend.internal
│       │   │   ├── depend.make
│       │   │   ├── flags.make
│       │   │   ├── link.txt
│       │   │   ├── progress.make
│       │   │   ├── sort.cpp.o
│       │   │   └── swap.cpp.o
│       │   └── swso.dir
│       │       ├── build.make
│       │       ├── cmake_clean.cmake
│       │       ├── CXX.includecache
│       │       ├── DependInfo.cmake
│       │       ├── depend.internal
│       │       ├── depend.make
│       │       ├── flags.make
│       │       ├── link.txt
│       │       ├── progress.make
│       │       ├── sort.cpp.o
│       │       └── swap.cpp.o
│       ├── cmake_install.cmake
│       └── Makefile
├── CMakeLists.txt
├── include
│   ├── sort.h
│   └── swap.h
├── lib
│   ├── libstatic_swso_1.0.0.a
│   └── libswso_1.0.0.so
├── main.cpp
└── src
    ├── CMakeLists.txt
    ├── sort.cpp
    └── swap.cpp

17 directories, 69 files


#运行编译生成的二进制可执行文件./bin/SWSO
Debug
15      10
arr1: 5 4 3 2 1 
arr2: 31.34 10.289 9.8 7.05 4 3.22
3
1
3



4.4 CMake交叉编译工程(如openwrt_x86_64架构)


  1. 在CMakeLists.txt同目录下额外编写一个openwrt_x86_64.cmake文件

    set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_C_COMPILER /home/peter/lede/staging_dir/toolchain-x86_64_gcc-8.4.0_musl/bin/x86_64-openwrt-linux-musl-gcc)
set(CMAKE_CXX_COMPILER /home/peter/lede/staging_dir/toolchain-x86_64_gcc-8.4.0_musl/bin/x86_64-openwrt-linux-musl-g++)

  2. 进入build文件夹执行如下指令：

    mkdir build
cd build
cmake -DCMAKE_TOOLCHAIN_FILE=../openwrt_x86_64.cmake ..
make


版权声明：本文为qq_23023937原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。