笨蛋学C++ 之 CMake的使用

CMake

生成可执行程序的流程

1. 预处理（-E参数 宏替换等）
2. 编译 gcc/msvc/clang（-S参数）
3. 汇编（-C参数 linux生成.o文件、windows生成.obj文件）
4. 连接（将多个二进制文件连接生成一个可执行的文件）

CMake命令执行流程

1. 编写CMakeLists.txt文件，进行配置
   • cmake——minimum_required(VERSION 3.20) #最小版本
   • project(HELLO) #项目名
   • add_executable(Hello hello.cpp) #由源文件生成可执行程序
2. cmake -B build
   • 创建build并在此目录下生成makefile或其他文件
3. cmake --build build
   • 生成项目

安装CMake

- sudo yum update

- sudo yum install epel-release

//若装不上报错 未找到匹配的参数: epel-release 错误：没有任何匹配: epel-release
//则执行命令 yum clean all

在官网下载：https://cmake.org/download/ 
找到 Linux x86_64 点击下载 cmake-3.29.2-linux-x86_64.tar.gz

然后上传该文件到根目录下，这里我用的xftp

- cd /

- ls 就会看到上传的文件

- cd /usr/local/bin/

- mkdir  cmake

- cd /

- cd cmake-3.29.2-linux-x86_64

- cp -r ./* /usr/local/bin/cmake/

- vim ~/.bashrc
在最下面输入：export PATH=$PATH:/usr/local/bin/cmake/bin/

退出
- ssource ~/.bashrc

- cmake --version

linux执行cpp文件

运行

- cmake -B build

- cmake --build build

此时的项目结构下会有CMakeLists.txt、build、运行的cpp文件
然后进入build 
- cd build

- cmake ..

- make

- ls

执行文件
./Hello

--------------------------------------------------------------------------------
此时的项目结构下会有CMakeLists.txt、build、运行的cpp文件
- build/Hello

删除

rm -rf build

基本语法

cmake命令构成

• cmake
• ctest
• cpack
• cmake-gui
• ccmake

运行.cmake文件，在CMake中如何打印信息

• cmake -P *.cmake

• cmake_minimum_required(VERSION 3.20)
  message("hello")
  
  # 换行
  message([[123
  123123]])
  
  # 获取CMAKE中的信息
  message(${CMAKE_VERSION})
  

---

• 不添加任何关键字：重要信息
• STATUS ：非重要消息
• WARNING：CMake 警告, 会继续执行
• AUTHOR_WARNING：CMake 警告 (dev), 会继续执行
• SEND_ERROR：CMake 错误, 继续执行，但是会跳过生成的步骤
• FATAL_ERROR：CMake 错误, 终止所有处理过程

变量操作set、list

• CMake中的变量分为两种
  • CMake提供
  • 自定义
• CMake变量的命名区分大小写，CMake中的变量在存储时都是字符串
• CMake获取变量：${变量名}
• 变量的基础操作是set()与unset()，可以用list或string操作变量

set

cmake_minimum_required(VERSION 3.20)

# 设置缓存变量
set(Var1 "CHINESE牛逼")
message(${Var1})

set("he llo" testvar)
message(${he\ llo})
set(t1 "zhangsan lisi")
message(${t1})

# 设置多个值
set(LISTVALUE a1;a2)
message(${LISTVALUE})

# $PATH
message($ENV{PATH})
set(ENV{CXX} "g++")
message($ENV{CXX})

# unset 取消设置缓存变量
unset(ENV{CXX})
message($ENV{CXX})

list

• 创建列表: 创建一个空的列表或包含初始值的列表。

  set(MY_LIST "")  # 创建一个空列表
  set(MY_LIST "value1" "value2" "value3")  # 创建一个包含三个元素的列表
  

• 访问列表元素: 通过索引访问列表中的元素。列表的索引从0开始。

  set(MY_LIST "first" "second" "third")
  message("${MY_LIST[0]}")  # 输出 "first"
  message("${MY_LIST[1]}")  # 输出 "second"
  

• 修改列表元素: 通过索引修改列表中的元素。

  set(MY_LIST "first" "second" "third")
  set(MY_LIST[1] "new_second")  # 将索引1处的元素修改为 "new_second"
  

• 列表长度: 获取列表的长度。

  set(MY_LIST "a" "b" "c")
  list(LENGTH MY_LIST LENGTH_OF_LIST)
  message("Length of list: ${LENGTH_OF_LIST}")  # 输出列表的长度
  

• 列表拼接: 将两个或多个列表拼接成一个。

  set(LIST_A "one" "two")
  set(LIST_B "three" "four")
  list(APPEND LIST_A LIST_B)  # LIST_A 现在变成 "one" "two" "three" "four"
  

• 列表插入: 在列表的指定位置插入一个或多个元素。

  set(MY_LIST "first" "third")
  list(INSERT MY_LIST 1 "second")  # 在索引1的位置插入 "second"
  

• 列表移除: 从列表中移除指定位置的元素或匹配特定值的元素。

  set(MY_LIST "first" "second" "third")
  list(REMOVE_AT MY_LIST 1)  # 移除索引1处的元素 "second"
  list(REMOVE_ITEM MY_LIST "third")  # 移除列表中所有的 "third"
  

• 列表查找: 查找某个值在列表中的索引。

  set(MY_LIST "first" "second" "third")
  list(FIND MY_LIST "second" INDEX)
  message("Index of 'second': ${INDEX}")  # 输出 "second" 的索引
  

• 列表反转: 反转整个列表。

  set(MY_LIST "first" "second" "third")
  list(REVERSE MY_LIST)
  

• 列表子序列: 获取列表的一部分作为子序列。

  set(MY_LIST "zero" "one" "two" "three" "four")
  list(SUBLIST MY_LIST 1 2 SUBLIST)  # 从索引1开始取两个元素，SUBLIST 变成 "one" "two"
  

• 列表分割: 使用分隔符将列表分割成多个子列表。

  set(MY_LIST "a;b;c;d")
  list(SPLIT MY_LIST ";" SPLIT_LIST)  # SPLIT_LIST 变成 "a", "b", "c", "d"
  

• 列表排序: 使用list(SORT ...)命令对列表中的元素进行排序。默认情况下，如果元素是数字，它们将按照数值顺序排序；如果元素是非数字字符串，它们将按照字典顺序排序。

  复制set(MY_LIST "banana" "apple" "cherry")
  list(SORT MY_LIST)  # 按照字典顺序排序列表
  

• 自定义排序: 如果你需要按照特定的规则对列表进行排序，可以使用list(SORT ...)命令的COMPARE选项，并提供一个自定义的比较函数。

  set(MY_LIST 5 3 1 4 2)
  list(SORT MY_LIST COMPARE NATURAL)  # 按照自然排序（数值大小）排序列表
  

• 反向排序: 使用ORDER关键字和REVERSE选项可以实现反向排序。

  set(MY_LIST "first" "second" "third")
  list(SORT MY_LIST ORDER REVERSE)  # 将列表反向排序
  

流程控制

条件流程控制

if(<条件>)
  # 如果条件为真，执行的命令
elseif(<条件>)
  # 如果第一个条件为假，且第二个条件为真，执行的命令
elseif(<条件>)
  # 更多的条件和命令
else()
  # 如果以上所有条件都为假，执行的命令
endif()

• AND：逻辑与
• OR：逻辑或
• NOT：逻辑非
• EQUAL：相等
• LESS：小于
• GREATER：大于
• LESS_EQUAL：小于等于
• GREATER_EQUAL：大于等于
• STREQUAL：字符串相等
• STRLESS：字符串小于
• STRGREATER：字符串大于
• VERSION_LESS：版本号小于
• VERSION_EQUAL：版本号相等
• VERSION_GREATER：版本号大于

cmake_minimum_required(VERSION 3.20.0)
set(VARBOOL TRUE)

if(VARBOOL)
    message(TRUE)
else()
    message(FALSE)
endif()

# NOT 取反
if(NOT VARBOOL)
    message(TRUE)
else()
    message(FALSE)
endif()

# OR 或
if(NOT VARBOOL OR VARBOOL)
    message(TRUE)
else()
    message(FALSE)
endif()

# AND 和
if(NOT VARBOOL AND VARBOOL)
    message(TRUE)
else()
    message(FALSE)
endif()


# 小于
if(1 LESS 2)
    message("1 LESS 2")
endif()

if("233" LESS 233)
    message("OK IS less")
endif()

if(2 EQUAL 2)
    message("2 EQUAL 2")
endif()

正则表达式匹配: MATCHES后面可以跟一个正则表达式，CMake会用这个正则表达式来匹配变量的值。

set(MY_VAR "hello_world")
if(MY_VAR MATCHES "^hello.*")
  message("The variable starts with 'hello'")
endif()

循环流程控制

• break
• continue

for

foreach(loop_var IN LIST list2 ...)
  # 循环体中的命令
  # loop_var 是循环变量，IN LIST 后面可以跟一个或多个列表
endforeach()

# 打印单个列表
set(MY_LIST a;b;c)
foreach(item IN LISTS MY_LIST)
    message("${item}")
    
endforeach()

# 打印多个列表
set(MY_LIST2 1;2;3)
foreach(item IN LISTS MY_LIST MY_LIST2)
    message("${item}")
endforeach()

# 使用matches
foreach(item IN LISTS MY_LIST)
    if(item MATCHES "a")
        message("this is a")
    endif()
    
endforeach()

# 遍历数值范围
foreach(item RANGE 1 5)
    message("Number ${item}")
    
endforeach()

message("------------------------")
# 循环中修改列表
foreach(item IN LISTS MY_LIST)
    if(item MATCHES "b")
        list(REMOVE_ITEM MY_LIST "${item}")
    endif()
    
    message("${item}")
endforeach()

foreach(item IN LISTS MY_LIST)
    message("${item}")
endforeach()

# break 和 continue
foreach(item IN LISTS MY_LIST2)
    if(item STREQUAL "2")
        break()
    endif()
    
    if(item STREQUAL "3")
        continue()
    endif()
    message("Additional info for ${item}")    
endforeach()

while

while(<condition>)
  # 循环体中的命令
endwhile()

set(VAR 0)
while(VAR LESS 10)
    message("current var = ${VAR}")
    # 将VAR+1的结果赋值给VAR
    math(EXPR VAR "${VAR} +1")
endwhile()

set(MY_VAR1 0)
set(MY_VAR2 0)

while(MY_VAR1 LESS 10 OR MY_VAR2 LESS 5)
    message("MY_VAR1:${MY_VAR1}, MY_VAR2:${MY_VAR2}")
    if(MY_VAR1 LESS 10)
        math(EXPR MY_VAR1 "${MY_VAR1} +1")
    endif()

    if(MY_VAR2 LESS 5)
        math(EXPR MY_VAR2 "${MY_VAR2} +1")
    endif()
endwhile()

函数

function(函数名 参数1 参数2)
  # 函数体中的命令
endfunction()

function(MyFunc FirstArg)
    message("MyFunc Name: ${CMAKE_CURRENT_FUNCTION}")
    message("FirstArg = ${FirstArg}")

    set(FirstArg "New Value")
    message("FirstArg : ${FirstArg}")

endfunction()


set(FirstArg "first value")
MyFunc(${FirstArg})

message("FirstArg = ${FirstArg} ")

作用域

全局作用域

# 在全局作用域中设置变量
set(GLOBAL_VAR "I am global")

# 定义一个函数
function(show_global)
    message("Function sees GLOBAL_VAR: ${GLOBAL_VAR}")
endfunction()

# 调用函数，即使在函数内部，也能访问全局变量
show_global() # 输出: Function sees GLOBAL_VAR: I am global

局部作用域

# 定义一个函数，其中包含局部变量
function(local_scope)
    set(LOCAL_VAR "I am local")
    message("LOCAL_VAR inside function: ${LOCAL_VAR}")
endfunction()

# 调用函数
local_scope() # 输出: LOCAL_VAR inside function: I am local

# 尝试访问局部变量，这将不会成功，因为它是局部的
message("LOCAL_VAR outside function: ${LOCAL_VAR}") # 什么也不输出，因为LOCAL_VAR在此不可用

目录作用域

# 在CMakeLists.txt文件中设置目录作用域变量
set(DIRECTORY_VAR "I am directory-scoped")

# 该变量在同一个CMakeLists.txt文件及其包含的子目录中可见
# 但在其他CMakeLists.txt文件中不可见

使用 PARENT_SCOPE

# 定义一个函数，尝试设置父作用域变量
function(set_parent)
    set(PARENT_VAR "I am set in function" PARENT_SCOPE)
endfunction()

set_parent()

# PARENT_VAR 被设置在函数调用的父作用域中
message("PARENT_VAR after function call: ${PARENT_VAR}") # 输出: I am set in function

命令行作用域

# 从命令行设置变量
cmake -DCMD_LINE_VAR="I am from command line" .

# 在CMakeLists.txt中检查变量
message("CMD_LINE_VAR: ${CMD_LINE_VAR}") # 输出: I am from command line

# CMD_LINE_VAR是命令行作用域的，只能在CMake配置时使用，不能在CMakeLists.txt文件中设置

环境变量作用域

# 访问环境变量
message("PATH from environment: $ENV{PATH}")

# 也可以设置环境变量
set(ENV{CUSTOM_ENV_VAR} "This is a custom environment variable")

变量覆盖

# 全局作用域中定义变量
set(SOME_VAR "This is global")

# 在函数中覆盖变量
function(override_var)
    set(SOME_VAR "This is local to function")
    message("Function: ${SOME_VAR}")
endfunction()

# 调用函数
override_var() # 输出: Function: This is local to function

# 函数外的变量值未改变
message("Global: ${SOME_VAR}") # 输出: Global: This is global

CACHE 关键字

# 使用 CACHE 关键字设置变量
set(CACHE_VAR "This is a cache variable" CACHE STRING "")

# 这个变量可以在 CMake GUI 或命令行中修改，并且是全局作用域的

宏

定义宏

macro(MyMacro)
  # 这里是宏的代码
  message("Hello, I am a macro!")
endmacro()

调用宏

MyMacro() # 这会打印 "Hello, I am a macro!"

宏的参数

macro(MyMacroWithName name)
  message("Hello, ${name}!")
endmacro()

MyMacroWithName(John) # 这会打印 "Hello, John!"

# 定义一个宏，它接收两个参数并打印出来
macro(print_two_values val1 val2)
  message("First value: ${val1}")
  message("Second value: ${val2}")
endmacro()

# 调用宏并传递参数
print_two_values("This is" "a test")

print_two_values("I want" "study")

test/test.cpp

#include <iostream>
#define NUM 5
using namespace std;
int main(void){

    int a = 10;

#ifdef DEBUG
        cout << "测试自定义宏" << endl;
#endif
        for(int i=0;i<NUM;i++){
            cout << "Hello World " << i << endl;
        }

    return 0;
}

test/CMakeLists.txt

cmake_minimum_required(VERSION 3.20)

project(helloworld)

# 添加宏定义
add_definitions(-DDEBUG)
add_executable(app test.cpp)

编写简单的CMakeLists文件

test/add.cpp

#include <stdio.h>
#include "head.h"

int add(int a, int b)
{
    return a+b;
}

test/sub.cpp

#include <stdio.h>
#include "head.h"

int subtract(int a, int b)
{
    return a-b;
}

test/mult.cpp

#include <stdio.h>
#include "head.h"

int multiply(int a, int b)
{
    return a*b;
}

test/div.cpp

#include <stdio.h>
#include "head.h"

double divide(int a, int b)
{
    return (double)a/b;
}

test/main.cpp

#include <stdio.h>
#include "head.h"

int main()
{
    int a = 20;
    int b = 12;
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", add(a, b));
    printf("a - b = %d\n", subtract(a, b));
    printf("a * b = %d\n", multiply(a, b));
    printf("a / b = %f\n", divide(a, b));
    return 0;
}

test/CMakeLists.txt

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

输入命令

# 进入以上文件的父级目录，需要ls就能看见以上文件，然后输入命令，生成makefile文件
cmake .

make

./app

----------------------------------------------------------------------------------------------
mkdir build

cd build

cmake ..

make

./app

运用set

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)
# 指定可执行程序生成的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)
# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})

搜索文件

aux_source_directory

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
# set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 使用搜索文件
# PROJECT_SOURCE_DIR就是cmake .执行的路径
aux_source_directory(${PROJECT_SOURCE_DIR} SRC)

# 指定执行的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)
# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})

file

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
# set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 使用搜索文件
# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)

# 指定执行的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)
# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})

指定头文件目录

mkdir src include
    
mv head.h include/
    
mv *.cpp src/

mkdir build
    
cd build
    
cmake ..
    
# 这里报错，可能是因为写入了没有保存，注意保存CMakeLists.txt文件
make
    
./app

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
# set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 使用搜索文件
# PROJECT_SOURCE_DIR就是cmake .执行的路径
# aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC)

# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)

# 指定执行的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)

# 包含头文件
include_directories(${PROJECT_SOURCE_DIR}/include())

# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})

制作库文件

制作动态库(可执行) libxxx.so

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
# set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 使用搜索文件
# PROJECT_SOURCE_DIR就是cmake .执行的路径
# aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC)

# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)

# 指定执行的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)

# 包含头文件
include_directories(${PROJECT_SOURCE_DIR}/include())

# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})


# 设置动态库
# add_library(calc SHARED ${SRC})

制作静态库 libxxx.a

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
# set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 使用搜索文件
# PROJECT_SOURCE_DIR就是cmake .执行的路径
# aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC)

# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)

# 指定执行的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)

# 包含头文件
include_directories(${PROJECT_SOURCE_DIR}/include())

# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})


# 设置动态库
# add_library(calc STATIC ${SRC})

发布文件

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 定义可执行程序(可执行程序名、对应的源文件)
# add_executable(app add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 或者
# add_executable(app add.cpp;div.cpp;sub.cpp;mult.cpp;main.cpp)

# 运用set
# set(SRC add.cpp div.cpp sub.cpp mult.cpp main.cpp)

# 使用搜索文件
# PROJECT_SOURCE_DIR就是cmake .执行的路径
# aux_source_directory(${PROJECT_SOURCE_DIR}/src SRC)

# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)

# 指定执行的路径
set(EXECUTABLE_OUTPUT_PATH /root/code/day_3/build)

# 包含头文件
include_directories(${PROJECT_SOURCE_DIR}/include())

# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

add_executable(app ${SRC})



# 指定库文件路径
set(LIBRARY_OUTPUT_PATH /root/code/day_3_ku)

# 设置动态库
add_library(calc SHARED ${SRC})

# 设置静态库
# add_library(calc STATIC ${SRC})

链接

链接静态库

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 使用搜索文件
# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)

# 包含头文件
include_directories(${PROJECT_SOURCE_DIR}/include)

# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

# 指定库文件路径
# set(LIBRARY_OUTPUT_PATH /root/code/day_3_ku)

# 设置动态库
# add_library(calc SHARED ${SRC})

# 设置静态库
# add_library(calc STATIC ${SRC})

# 链接静态库 库名
link_libraries(calc)
# 链接静态库路径
# staticlib存放的静态库文件libcalc.a
link_directories(${CMAKE_CURRENT_SOURCE_DIR}/staticlib)

add_executable(app ${SRC})

链接动态库

# 指定版本
cmake_minimum_required(VERSION 3.20)

# 定义工程名
project(day_3)

# 使用搜索文件
# 使用file
# GLOB就是当前目录，SRC就是路径 CMAKE_CURRENT_SOURCE_DIR就是CMakeLists.txt所在的目录
# 也可以使用 file(GLOB SRC ${PROJECT_SOURCE_DIR})
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)

# 包含头文件
include_directories(${PROJECT_SOURCE_DIR}/include)

# 指定CMake的标准
set(CMAKE_CXX_STANDARD 11)

# 指定库文件路径
# set(LIBRARY_OUTPUT_PATH /root/code/day_3_ku)

# 设置动态库
# add_library(calc SHARED ${SRC})

# 设置静态库
# add_library(calc STATIC ${SRC})

# 找到动态库的存放路径
link_directories(${CMAKE_CURRENT_SOURCE_DIR}/sharelib)

add_executable(app ${SRC})

# 链接动态库
target_link_libraries(app calc)

写入源码路径

test/person/student.h

#pragma once

#include <iostream>
#include <string>

using namespace std;

class Student{
public:
    void study();
};

test/person/student.cpp

#include "student.h"

void Student::study(){
    cout << "我在学习C++" << endl;
}

test/main.cpp

#include <iostream>
#include <string>
#include "person/student.h"

using namespace std;

int main(void){
    Student students;
    students.study();
    return 0;
}

test/CMakeLists.txt

cmake_minimum_required(VERSION 3.20.0)

project(Person CXX)

add_executable(Person main.cpp person/student.cpp)

调用子目录cmake脚本

test/person/student.h

#pragma once

#include <iostream>
#include <string>

using namespace std;

class Student{
public:
    void study();
};

test/person/student.cpp

#include "student.h"

void Student::study(){
    cout << "我在学习C++" << endl;
}

test/person/teacher.h

#pragma once

#include <iostream>
#include <string>
using namespace std;

class Teacher{
public:
    void teach();
};

test/person/teacher.cpp

#include <iostream>
#include <string>
#include "teacher.h"

using namespace std;

void Teacher::teach(){
    cout << "我在教C++" << endl;
}

test/person/person.cmake

set(person_sources person/student.cpp person/teacher.cpp)

test/main.cpp

#include <iostream>
#include <string>
#include "person/student.h"
#include "person/teacher.h"

using namespace std;

int main(void){
    Student students;
    students.study();

    Teacher teacher;
    teacher.teach();
    return 0;
}

test/CMakeLists.txt

cmake_minimum_required(VERSION 3.20.0)

project(Person CXX)

# 导入文件
include(person/person.cmake)
add_executable(Person main.cpp ${person_sources})

CMakeLists嵌套

test/CMakeLists.txt

cmake_minimum_required(VERSION 3.15)
project(TestCMake)

# 定义变量
# 静态库生成路径
set(STATICLIBPATH ${PROJECT_SOURCE_DIR}/lib)

# 可执行程序的存储目录
set(EXECPATH ${PROJECT_SOURCE_DIR}/bin)

# 头文件路径
set(HEADPATH ${PROJECT_SOURCE_DIR}/include)

# 库文件名字
set(CALCLIB calc)

# 可执行程序名字
set(APPNAME app)

# 当前节点添加子目录
add_subdirectory(calc)
add_subdirectory(test)

test/calc/CMakeLists.txt

cmake_minimum_required(VERSION 3.15)
project(Calc)

# 搜索源文件
aux_source_directory(./ SRC)
# 头文件路径
include_directories(${HEADPATH})

# 设置输出路径
set(LIBRARY_OUTPUT_PATH ${STATICLIBPATH})
# 添加静态库路径
add_library(${CALCLIB} STATIC ${SRC})

test/calc/add.cpp

#include <iostream>
#include "calc.h"
using namespace std;

double Calc::add(double a,double b)
{
    return (double)a+b;
}

test/calc/sub.cpp

#include<stdio.h>
#include "calc.h"

double Calc::sub(double a,double b)
{
    return (double)a-b;
}

test/calc/mult.cpp

#include<stdio.h>
#include "calc.h"

double Calc::mult(double a,double b)
{
    return (double)a*b;
}

test/calc/div.cpp

#include<stdio.h>
#include "calc.h"

double Calc::div(double a,double b)
{
    if(a!=0){    
        return (double)a/b;
    }
    return 0;
}

test/test/CMakeLists.txt

cmake_minimum_required(VERSION 3.15)
project(Test)

aux_source_directory(./ SRC)
# 头文件路径
include_directories(${HEADPATH})

# 静态库路径
link_directories(${STATICLIBPATH})

# 链接静态库
link_libraries(${CALCLIB})

set(EXECUTABLE_OUTPUT_PATH ${EXECPATH})

# 生成可执行程序
add_executable(${APPNAME} ${SRC})

test/calc.cpp

#include <iostream>
#include <string>
#include "calc.h"

int main(void){

    Calc calc;
    cout << calc.add(1,2) << endl;
    cout << calc.sub(1,2) << endl;
    cout << calc.mult(1,2) << endl;
    cout << calc.div(1,2) << endl;


    return 0;
}

运行

cmake -B build

cmake --build build

./bin/app

静态库中链接静态库

静态库中链接动态库