cmake 创建和使用静态库(极简版)

1.创建静态库

项目名为my_sort_static_lib

1.源码如下

1. CMakePresets.json

{
    "version": 6,
    "configurePresets": [
        {
            "name": "mingw",
            "displayName": "GCC 9.2.0 mingw32",
            "description": "Using compilers: gcc, g++",
            "generator": "MinGW Makefiles",
            "binaryDir": "${sourceDir}/build/${presetName}",
            "cacheVariables": {
                "CMAKE_C_COMPILER": "gcc",
                "CMAKE_CXX_COMPILER": "g++",
                "CMAKE_MAKE_PROGRAM": "mingw32-make",
                "CMAKE_BUILD_TYPE": "Debug",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            }
        }
    ],
    "buildPresets": [
        {
            "name": "mingwbuild",
            "displayName": "Build with MinGW",
            "description": "Build the project using the mingw configure preset.",
            "configurePreset": "mingw"
        }
    ]
}

2. CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(my_sort_static_lib VERSION 1.0.0 LANGUAGES CXX)

include(GNUInstallDirs)

# C++ 标准设置
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

add_subdirectory(src)

3. src\CMakeLists.txt

file(GLOB SORT_UTILS_SOURCES CONFIGURE_DEPENDS
    "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
    "${CMAKE_CURRENT_SOURCE_DIR}/*.cc"
    "${CMAKE_CURRENT_SOURCE_DIR}/*.cxx"
)

add_library(my_sort_static_lib STATIC
    ${SORT_UTILS_SOURCES}
)

4. src\sort_algorithms.h

#ifndef SORT_ALGORITHMS_H
#define SORT_ALGORITHMS_H

#include <vector>

namespace sort_algorithms {

// 冒泡排序：重复交换相邻逆序元素，返回排序后的副本。
std::vector<int> bubble_sort(std::vector<int> values);

// 选择排序：每轮选择未排序区间的最小值，返回排序后的副本。
std::vector<int> selection_sort(std::vector<int> values);

// 插入排序：把当前元素插入到前方已排序区间，返回排序后的副本。
std::vector<int> insertion_sort(std::vector<int> values);

// 归并排序：递归拆分并合并有序区间，返回排序后的副本。
std::vector<int> merge_sort(std::vector<int> values);

// 快速排序：基于枢轴分区后递归排序，返回排序后的副本。
std::vector<int> quick_sort(std::vector<int> values);

} // namespace sort_algorithms

#endif

5. src\sort_algorithms.cpp

#include "sort_algorithms.h"

#include <algorithm>
#include <cstddef>

namespace sort_algorithms {
namespace {

// 对 [left, right) 区间做归并排序，buffer 用作合并时的临时空间。
void merge_sort_range(std::vector<int>& values, std::vector<int>& buffer, std::size_t left, std::size_t right)
{
    if (right - left <= 1) {
        return;
    }

    const std::size_t mid = left + (right - left) / 2;
    merge_sort_range(values, buffer, left, mid);
    merge_sort_range(values, buffer, mid, right);

    // 两个子区间都已经有序，把较小元素依次写入 buffer。
    std::size_t i = left;
    std::size_t j = mid;
    std::size_t k = left;

    while (i < mid && j < right) {
        buffer[k++] = values[i] <= values[j] ? values[i++] : values[j++];
    }
    while (i < mid) {
        buffer[k++] = values[i++];
    }
    while (j < right) {
        buffer[k++] = values[j++];
    }

    // 把合并后的有序结果复制回原数组对应区间。
    for (std::size_t index = left; index < right; ++index) {
        values[index] = buffer[index];
    }
}

// 对闭区间 [left, right] 做快速排序分区和递归处理。
void quick_sort_range(std::vector<int>& values, int left, int right)
{
    if (left >= right) {
        return;
    }

    const int pivot = values[left + (right - left) / 2];
    int i = left;
    int j = right;

    // 从两端向中间扫描，把小于 pivot 的元素放左侧，大于 pivot 的元素放右侧。
    while (i <= j) {
        while (values[i] < pivot) {
            ++i;
        }
        while (values[j] > pivot) {
            --j;
        }
        if (i <= j) {
            std::swap(values[i], values[j]);
            ++i;
            --j;
        }
    }

    if (left < j) {
        quick_sort_range(values, left, j);
    }
    if (i < right) {
        quick_sort_range(values, i, right);
    }
}

} // namespace

std::vector<int> bubble_sort(std::vector<int> values)
{
    for (std::size_t end = values.size(); end > 1; --end) {
        bool swapped = false;

        // 每轮把当前未排序区间的最大值"冒泡"到末尾。
        for (std::size_t i = 1; i < end; ++i) {
            if (values[i - 1] > values[i]) {
                std::swap(values[i - 1], values[i]);
                swapped = true;
            }
        }

        // 如果本轮没有交换，说明数组已经有序，可以提前结束。
        if (!swapped) {
            break;
        }
    }
    return values;
}

std::vector<int> selection_sort(std::vector<int> values)
{
    for (std::size_t i = 0; i < values.size(); ++i) {
        std::size_t min_index = i;

        // 在未排序区间中寻找最小值的位置。
        for (std::size_t j = i + 1; j < values.size(); ++j) {
            if (values[j] < values[min_index]) {
                min_index = j;
            }
        }
        std::swap(values[i], values[min_index]);
    }
    return values;
}

std::vector<int> insertion_sort(std::vector<int> values)
{
    for (std::size_t i = 1; i < values.size(); ++i) {
        const int current = values[i];
        std::size_t j = i;

        // 将比 current 大的元素右移，给 current 腾出插入位置。
        while (j > 0 && values[j - 1] > current) {
            values[j] = values[j - 1];
            --j;
        }
        values[j] = current;
    }
    return values;
}

std::vector<int> merge_sort(std::vector<int> values)
{
    // buffer 只分配一次，递归过程中复用，避免每层递归重复分配。
    std::vector<int> buffer(values.size());
    merge_sort_range(values, buffer, 0, values.size());
    return values;
}

std::vector<int> quick_sort(std::vector<int> values)
{
    // 空数组不进入递归，避免 size_t 到 int 转换时出现下溢。
    if (!values.empty()) {
        quick_sort_range(values, 0, static_cast<int>(values.size() - 1));
    }
    return values;
}

} // namespace sort_algorithms

2.编译

cmake --preset mingw
cmake --build --preset mingwbuild

3.手动安装到C:\install\my_sort_static_lib

1. sort_algorithms.h
   复制sort_algorithms.h到C:\install\my_sort_static_lib\include目录下
2. libmy_sort_static_lib.a
   复制libmy_sort_static_lib.a到C:\install\my_sort_static_lib\lib目录下

2.创建一个项目使用静态库

1.源码如下

1. CMakePresets.json

{
    "version": 6,
    "configurePresets": [
        {
            "name": "mingw",
            "displayName": "MinGW GCC",
            "generator": "MinGW Makefiles",
            "binaryDir": "${sourceDir}/build/${presetName}",
            "cacheVariables": {
                "CMAKE_CXX_COMPILER": "g++",
                "CMAKE_MAKE_PROGRAM": "mingw32-make",
                "CMAKE_BUILD_TYPE": "Debug",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
                "CMAKE_CXX_USE_RESPONSE_FILE_FOR_INCLUDES": "OFF",
                "CMAKE_PREFIX_PATH": "C:\\install\\my_sort_static_lib"
            }
        }
    ],
    "buildPresets": [
        {
            "name": "mingwbuild",
            "displayName": "Build with MinGW",
            "configurePreset": "mingw"
        }
    ]
}

2. CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(use_my_sort_static_lib VERSION 1.0.0 LANGUAGES CXX)

# 使用固定的 C++17 标准，确保消费端与示例静态库的语言配置一致。
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

add_executable(use_my_sort_static_lib src/main.cpp)

# CMAKE_PREFIX_PATH 已在 CMakePresets.json 中设置为 C:\install\my_sort_static_lib
# 添加头文件搜索路径（等价于 g++ -I）
target_include_directories(use_my_sort_static_lib PRIVATE
    "${CMAKE_PREFIX_PATH}/include"
)

# 添加库文件搜索路径（等价于 g++ -L）
target_link_directories(use_my_sort_static_lib PRIVATE
    "${CMAKE_PREFIX_PATH}/lib"
)

# 链接静态库（CMake 会在上面的 link directories 中查找 libmy_sort_static_lib.a）（等价于 g++ -lmy_sort_static_lib）
target_link_libraries(use_my_sort_static_lib PRIVATE
    my_sort_static_lib
)

4. src\main.cpp

#include <iostream>
#include <vector>

#include <sort_algorithms.h>

int main()
{
    // 使用同一组输入演示 my_sort_static_lib 中的三种排序算法。
    const std::vector<int> data = {5, 3, 8, 1, 9, 2, 7, 4, 6};

    std::cout << "原始数组: ";
    for (const int value : data) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    const auto quick_sorted = sort_algorithms::quick_sort(data);
    std::cout << "快速排序: ";
    for (const int value : quick_sorted) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    const auto bubble_sorted = sort_algorithms::bubble_sort(data);
    std::cout << "冒泡排序: ";
    for (const int value : bubble_sorted) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    const auto merge_sorted = sort_algorithms::merge_sort(data);
    std::cout << "归并排序: ";
    for (const int value : merge_sorted) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    return 0;
}

2.编译运行

编译

cmake -S . --preset mingw
cmake --build --preset mingwbuild

运行

.\build\mingw\use_my_sort_static_lib.exe

3.使用cmake install安装静态库

1.src\CMakeLists.txt

参考文档

cmake install targets

cmake GNUInstallDirs

GNUInstallDirs常见变量：

${CMAKE_INSTALL_BINDIR} → bin

${CMAKE_INSTALL_LIBDIR} → lib / lib64

${CMAKE_INSTALL_INCLUDEDIR} → include

${CMAKE_INSTALL_DATAROOTDIR} → share

增加如下行

#https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
include(GNUInstallDirs)
# https://cmake.org/cmake/help/latest/command/install.html#targets
INSTALL(TARGETS my_sort_static_lib
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

INSTALL(FILES sort_algorithms.h 
    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

INSTALL(FILES ../readme.md
    DESTINATION ${CMAKE_INSTALL_INFODIR}
)

2.CMakePresets.json

在configurePresets的mingw的cacheVariables中增加如下行，用以配置安装前缀

"CMAKE_INSTALL_PREFIX": "C:/install/my_sort_static_lib"

3.执行安装命令

由于我们修改了cmake，因此要重新刷新变量

cmake -S . --preset mingw

再安装

cmake --install build/mingw

安装后，使用静态库的方法依然不变

4.cmake install安装和使用进阶