c++ 20 module 模块使用 cmake

已于 2023-05-16 10:01:34 修改
阅读量1.9k 收藏 6
点赞数 4
分类专栏： 后端技术 文章标签： c++20 c++
于 2023-04-27 21:16:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yudaichenydc/article/details/130415087
版权

全中文网第一个讲清楚了module 与cmake结合使用

1、模块概述

ixx 声明文件
icc 实现文件
async_simple框架用的后缀是cppm

可以在模块中用模板，我是直接export的命名空间！！！
学习可以看看这篇博客学习

2、cmake 如何支持的？

cmake 官网文档链接：
https://cmake.org/cmake/help/latest/prop_tgt/CXX_MODULE_SETS.html

CXX_MODULE_SETS¶
New in version 3.25.

Note Experimental. Gated by CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API
Read-only list of the target's PRIVATE and PUBLIC C++ module sets (i.e. all file sets with the type CXX_MODULES). Files listed in these file sets are treated as source files for the purpose of IDE integration.

C++ module sets may be defined using the target_sources() command FILE_SET option with type CXX_MODULES.

See also CXX_MODULE_SET_<NAME>, CXX_MODULE_SET and INTERFACE_CXX_MODULE_SETS.

1、必须是3.25以上的版本
2、模块文件使用target_sources()导入
3、需要设置CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API参数
4、linux 平台：必须使用ninja 1.11以上编译，github上有二进制包，单个文件的,clang大于15版本，cmake project name 必须等到CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API 设置完后才可以设置
6、windows平台mvsc可以直接使用，忽略以上3、4条，因为他可以自动扫描依赖没这么麻烦，但是必须保持最新版本

3、demo

CMakeLists.txt:

cmake_minimum_required(VERSION 3.25.2)

    
if (UNIX)
   
    set(CMAKE_GENERATOR "/usr/bin/ninja")
    set(CMAKE_C_COMPILER "clang-16")
    set(CMAKE_CXX_COMPILER "clang++-16")

   set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "2182bf5c-ef0d-489a-91da-49dbc3090d2a")
   set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "clang")
   set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
# 必须设置，否则他会去找gcc的头文件
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem /usr/lib/llvm-16/lib/clang/16/include -Wall -Wextra -Wunused-parameter")
 include(cxx_modules_rules_clang.cmake)
endif()

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

if (WIN32)
        add_definitions("/utf-8")
        add_definitions("/wd4828 /wd4267")
        #set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zf /O3 /openmp /MP /std:c++20 /bigobj /await:strict")
        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Zf /O0 /openmp /MP /std:c++20 /bigobj /await:strict")
        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zf /O3 /openmp /MP /std:c20 /bigobj /await:strict")
        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Zf /O0 /openmp /MP /std:c20 /bigobj /await:strict")
        #[如果确认不需要PDB, 即不需要调试开源库, 完全可以在设置里将/Zi或/ZI去掉]

        # 文件utf-8
        add_compile_options("$<$<C_COMPILER_ID:MSVC>:/utf-8>")
        add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")

    else()
   
        # Wreturn-type 协程是空实现
        #-fmodules-ts 模块
        #-fcoroutines-ts 协程
        #-fconcepts-ts 概念
        #-fsanitize=address 检查内存溢出
        #-freport-bug 打印完整的编译 bug
        # -Wunused-result 忽略返回结果
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20  -fmodules-ts -fsanitize=address -fcoroutines-ts -fconcepts-ts -fpermissive -Wreturn-type -freport-bug -Wunused-result")
        set(CXX_FLAGS "${CXX_FLAGS} -std=c++20 -fmodules-ts -fsanitize=address -fcoroutines-ts -fconcepts-ts -fpermissive -Wreturn-typ -freport-buge -Wunused-result")

        #add_compile_options(-fmodules)
        #add_compile_options(-fbuiltin-module-map)
        #add_compile_options(-fimplicit-module-maps)
        #add_compile_options(-fprebuilt-module-path=${PREBUILT_MODULE_PATH})

    endif ()
# 源文件
file(GLOB_RECURSE SOURCE_FILES
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.c
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.ui
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.qrc
        )

# 头文件
file(GLOB_RECURSE CURRENT_HEADERS
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.h
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.h
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp)


#！！！ 重点递归查找模板文件 FAST_MODULES保存所有的模块文件
file(GLOB_RECURSE FAST_MODULES
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.ixx
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cxx
        ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cppm)

# 构建可执行程序
add_executable(
${APP_NAME}#[[项目名称]] 
${SOURCE_FILES} #[[源文件]]
${CURRENT_HEADERS} #[[头文件]]
${CMAKE_CURRENT_SOURCE_DIR}/run/main.cpp #[[主函数入口]])

#！！！追加模板
target_sources(
        ${APP_NAME}
        PUBLIC
        ${FAST_MODULES}
)

什么是${CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS}？

clang-scan-deps-${llvm版本号}

如何使用这个?

apt install clang-tools-16

获取不到这个版本？

https://apt.llvm.org/ 这个网址进去找到对应的扩展源

什么是CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API ？

cmake实验性的version号，github-cmake上可以找到这个东西

下面的string（…） 就是调用这个clang-scan-deps扫描工具

cxx_modules_rules_clang.cmake:

set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
  "${CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS}"
  " -format=p1689"
  " --"
  " <CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS>"
  " -x c++ <SOURCE> -c -o <OBJECT>"
  " -MT <DYNDEP_FILE>"
  " -MD -MF <DEP_FILE>"
  " > <DYNDEP_FILE>")
set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "clang")
set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")

# Default to C++ extensions being off. Clang's modules support have trouble
# with extensions right now.
set(CMAKE_CXX_EXTENSIONS OFF)

4.测试文件

//声明是一个模板
module;

#include <iostream>
#include <tuple>
#include <array>
#include <utility>

// 导出.hpp文件后，从这个模块开始，后面用这个文件智能import <utility>
export import <utility>

// 导出整个命名空间
export module tuple_utils;
namespace tuple_utils{
/***********递归+特化方式遍历打印tuple***************/
    template<typename Tuple, std::size_t N>
    struct tuple_printer {
        static void print(const Tuple &t) {
            tuple_printer<Tuple, N - 1>::print(t);
            std::cout << ", " << std::get<N - 1>(t);
        }
    };

    template<typename Tuple>
    struct tuple_printer<Tuple, 1> {
        static void print(const Tuple &t) {
            std::cout << std::get<0>(t);
        }
    };

    template<typename... Args>
    void print_tuple(const std::tuple<Args...> &t) {
        tuple_printer<decltype(t), sizeof...(Args)>::print(t);
        std::cout << std::endl;
    }

/***********使用流的方式，这里用到了C++14的index_sequence****************/
    template<typename Char, typename Traits, typename Tuple, std::size_t... Index>
    void print_tuple_impl(std::basic_ostream<Char, Traits> &os, const Tuple &t, std::index_sequence<Index...>) {
        using swallow = int[]; // guaranties left to right order
        (void) swallow{0, (void(os << (Index == 0 ? "" : ", ") << std::get<Index>(t)), 0)...};
    }

    template<typename Char, typename Traits, typename... Args>
    decltype(auto) operator<<(std::basic_ostream<Char, Traits> &os, const std::tuple<Args...> &t) {
        os << "(";
        print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
        return os << ")";
    }

/***********将std::array转换成std::tuple，这里用到了C++14的index_sequence****************/
    template<typename Array, std::size_t... Index>
    decltype(auto) array2tuple_impl(const Array &a, std::index_sequence<Index...>) {
        return std::make_tuple(a[Index]...);
    }

    template<typename T, std::size_t N>
    decltype(auto) array2tuple(const std::array<T, N> &a) {
        return array2tuple_impl(a, std::make_index_sequence<N>{});
    }

/***********通过元素类型获取元素的值****************/
    template<typename T, std::size_t N, typename... Args>
    struct index_of;

    template<typename T, std::size_t N, typename... Args>
    struct index_of<T, N, T, Args...> : std::integral_constant<int, N> {
    };

    template<typename T, std::size_t N, typename U, typename... Args>
    struct index_of<T, N, U, Args...> : std::integral_constant<int, index_of<T, N + 1, Args...>::value> {
    };

    template<typename T, std::size_t N>
    struct index_of<T, N> : std::integral_constant<int, -1> {
    };

    template<typename T, typename... Args>
    T get_element_by_type(const std::tuple<Args...> &t) {
        return std::get<index_of<T, 0, Args...>::value>(t);
    };

/***********通过std::tuple作为参数调用函数****************/
    template<typename Function, typename Tuple, std::size_t... Index>
    decltype(auto) invoke_impl(Function &&func, Tuple &&t, std::index_sequence<Index...>) {
        return func(std::get<Index>(std::forward<Tuple>(t))...);
    };

    template<typename Function, typename Tuple>
    decltype(auto) invoke(Function &&func, Tuple &&t) {
        constexpr auto size = std::tuple_size<typename std::decay<Tuple>::type>::value;
        return invoke_impl(std::forward<Function>(func), std::forward<Tuple>(t), std::make_index_sequence<size>{});
    };

/***********make_from_tuple****************/
    template<typename T, typename Tuple, std::size_t... Index>
    decltype(auto) make_from_tuple_impl(Tuple &&t, std::index_sequence<Index...>) {
        return T{std::get<Index>(std::forward<Tuple>(t))...};
    };

    template<typename T, typename Tuple>
    decltype(auto) make_from_tuple(Tuple &&t) {
        constexpr auto size = std::tuple_size<typename std::decay<Tuple>::type>::value;
        return make_from_tuple_impl<T>(std::forward<Tuple>(t), std::make_index_sequence<size>{});
    };
}
Bender_ydc
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
gmake-d:带有内置D支持的GNU Make
04-22
gmake -d 此存储库包含GNU Make的原始副本，其中D设置为默认设置。 这使您可以编写用于D代码的标准Makefile。 它提供了配音的替代方法。 您可以直接构建此存储库，也可以使用dlang.diff文件来修补自己的GNU Make存储库。 我将至少尝试保持最新的GNU Make版本。 注意事项 默认的D编译器是GDC。 如果要使用其他编译器，请设置DC环境变量或将第553行更改为以下之一： "DC", "ldc" 或者 "DC", "dmd" 取决于您是否更喜欢LDC或DMD作为默认的D编译器。
一步一步学Cmake 之 自定义模块(Module)
wanzew的博客
01-30 8040
Table of Contents 1. 为什么要自定义模块 2. 如何自定义模块 2.1 准备文件 2.2 编写CMakeLists.txt 1. 为什么要自定义模块 项目一般从CMakeLists.txt开始编写，但是随着时间的推移，CMakeLists.txt文件会变的越来越大，这个时候我们就需要将CMakeLists.txt文件拆开分写成几个小的模块，这样做的好处是： １．主...
【Cmake MODULE模块库】深度理解CMake中的add_library: MODULE的全面指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
08-23 1026
在CMake中，`add_library`命令可以创建四种类型的库：`SHARED`，`STATIC`，`MODULE`和`INTERFACE`。本章将主要关注`MODULE`库。 MODULE（模块库）是一种特殊类型的动态库，它可以在程序运行时被加载。与普通动态库（`SHARED`库）的主要区别在于，MODULE库通常不会被链接到其他目标（例如，另一个库或可执行文件）。相反，它们通常在运行时使用特定的系统调用（如dlopen在Unix-like系统中，或LoadLibrary在Windows系统中）动态
CMake构建C++20 Module实例
arong_xu的博客
03-27 1075
C++20实战
cppm:C ++的独立模块体系结构。-开源
04-25
C ++ M是与编译器和操作系统无关的组件体系结构，其设计重点是C ++ 11。 C ++ M的基本原理与COM和CORBA相似，但是一些关键的设计决策有很大的不同。 与前者相比，一些主要区别是使用分层名称空间和使用人类可读的“完全限定名称”而不是GUID，以及对支持仅允许以二进制形式分发模块的基本元数据的支持允许大量重用。 组件代理是ABI抽象的核心，它允许C ++ M模型自动进行参数编组，自动生命周期管理（RAII），并支持跨组件（和编译器/库）边界的异常处理。 这些代理是由特殊的预编译器根据“模块描述语言”生成的。
CMakeCxxModules:用于C ++模块TS项目的CMake模块
04-10
CMake C ++模块 用于C ++模块TS项目的CMake模块。 警告 这是一个实验性CMake模块，它使用C ++ Modules TS的当前实现。 有很多问题，不应在生产代码中使用。 支持的编译器 lang 7 MSVC [WIP] GCC 用法 下载CXXModules.cmake文件，并将其包含在您的CMake项目中。 基本用法是将文件与CMakeLists.txt放在同一目录中： include (CXXModules.cmake) 另外，该文件可以存储在CMAKE_MODULE_PATH引用的路径中，因此您只能键入： include (CXXModules) 现在，您可以访问启用C ++模块支持的特殊功能。 target_enable_cxx_modules为项目启用C ++模块支持。 它只是为C ++模块设置了编译器选项。 add_module_libr
GNU开发工具——CMake模块
weixin_33928467的博客
05-19 251
GNU开发工具——CMake模块 一、find_packge高级功能 1、find_package的模式 find_package()有Module模式(基本用法)和Config模式(完全用法），其中Module模式是基础，Config模式则提供复杂高级功能。find_package是否使用Config模式可以通过下列条件判断：（1）find_package()中指定CONFIG关键字（2）fin...
CMake | CMake模块
该用户还没想到好的昵称的博客
03-07 7511
将CMakeLists.txt文件分成几个模块；CMake相关命令：1.CMAKE_MODULE_PATH；2.include
编写自己的 cmake module模块 通过find_package指定编译自己安装的包如opencv cuda
yanerhao的专栏
09-03 2373
cmake 主要命令解释 FIND_PATH（VAR file path1 path2）将file文件路径赋值给变量 FIND_LIBRARY（VAR lib path）将lib文件路径赋值被变量 install(FILES flie DESTINATION dir_path) #执行make install时，把file拷贝到dir_path install(PROGRAMS file ...
c++20编程体验
fengforky的专栏
12-18 227
用vscode右击 run interactive。安装vim， cmake。
Cmake 之 自定义模块(Module)
weixin_42301918的博客
05-05 253
cmake自己写库的modules文件
cmake自定义模块使用示例
11-08
cmake中经常使用find_package寻找模块，使用起来非常方便．find_package的原理是什么呢？如何自己写个模块提供给别人使用?如果别人希望用find_package的形式使用你的模块中的库，我该如何用cmake写这个库呢？ 这个...
cmake_example:使用基于CMake的构建系统构建的示例pybind11模块
05-12
使用基于CMake的构建系统构建的模块示例。 这对于具有现有CMake项目结构的C ++代码库很有用。 在许多情况下，这被取代，后者使用 ，这是CMake制造商的工具，旨在允许从CMake驱动Python包。 但是，在某些情况下，您...
mod-ahbot:azerothcore的模块
05-18
Simply place the module under the `modules` directory of your AzerothCore source. 3. Import the SQL manually to the right Database (auth, world or characters) or with the `db_assembler.sh` (if `...
module_pidx:适用于OSPRay的PIDX渲染示例应用程序
05-09
将存储库克隆到OSPRay模块目录中，然后运行CMake来构建OSPRay并传递-DOSPRAY_MODULE_PIDX=ON来构建模块的影片渲染器和渲染器，并-DOSPRAY_MODULE_PIDX_VIEWER=ON来构建远程查看器客户端。 需要PIDX和TurboJPEG 1.5.x...
spore-nest-module:突触可塑性与在线强化学习
05-19
NEST模块SPORE： 突触可塑性与在线强化学习SPORE是的自定义模块，它提供了一个模拟框架，... git clone https://github.com/IGITUGraz/spore-nest-modulecd spore-nest-modulemkdir build && cd buildcmake ..makemake
C++20：方向之争 C++20 特性 模块 协程 无栈协程 编译期 计算支持 静态反射 模式匹配
最新发布
万有文的博客
04-28 998
C++20作为C++语言的一个新标准，带来了许多新的特性和改进，同时也引发了一些关于发展方向的争议。这些争议主要集中在如何平衡语言的复杂性、性能、易用性以及与其他编程语言和技术的集成等方面。首先，C++20引入了一些新的语言特性和库，如concepts（概念）、ranges（范围）、coroutines（协程）等，这些特性旨在提高代码的可读性、可维护性和性能。然而，这些新特性的引入也增加了语言的复杂性，使得学习和掌握C++变得更加困难。
《Beginning C++20 From Novice to Professional》第六章 Pointers and References
xiaowenhao的博客
04-25 681
指针和引用都是间接寻址在高级语言中的表现，一是提供效率上的保证，二是给动态内存的操作带来很多方便。
《Beginning C++20 From Novice to Professional》第五章 Arrays and Loops
xiaowenhao的博客
04-23 677
循环和数组确实是联系比较紧密的两个基础语法，数组让我们管理大量同类对象，循环可以简单地遍历一个范围内的元素。
c++ cmake 多文件项目，多个cmakelists.txt,每个模块都可以单独编译运行
06-02
在 C++ 多文件项目中，可以通过将代码分成多个模块并使用多个 CMakeLists.txt 文件来管理它们。为了使每个模块都可以单独编译运行，我们需要为每个模块创建一个单独的 CMakeLists.txt 文件，并将其设置为可执行文件。 假设我们有以下项目结构： ``` myproject/ ├── CMakeLists.txt ├── module1/ │ ├── CMakeLists.txt │ ├── include/ │ │ └── module1.h │ └── src/ │ └── module1.cpp └── module2/ ├── CMakeLists.txt ├── include/ │ └── module2.h └── src/ └── module2.cpp ``` 其中，`myproject ` 目录下的 `CMakeLists.txt` 文件是主 CMakeLists.txt 文件，它用于管理整个项目。`module1` 目录和 `module2` 目录是两个子模块，每个子模块都有自己的 `CMakeLists.txt` 文件、头文件和源文件。 现在，我们需要使用 CMake 来构建这个项目。我们可以在 `module1` 目录下创建一个名为 `CMakeLists.txt` 的文件，并添加以下内容： ```cmake # 添加头文件搜索路径 include_directories(include) # 添加源文件 add_executable(module1 src/module1.cpp) # 暴露头文件 target_include_directories(module1 PUBLIC include) ``` 该 `CMakeLists.txt` 文件指定了 `module1` 子模块的构建规则。`include_directories` 命令添加了头文件搜索路径，它告诉 CMake 在 `include` 目录中查找头文件。`add_executable` 命令编译 `module1.cpp` 源文件并生成一个可执行文件 `module1`。最后，`target_include_directories` 命令将 `include` 目录暴露给其他模块，以便它们可以包含 `module1.h` 头文件。 然后，在 `module2` 目录下创建一个名为 `CMakeLists.txt` 的文件，并添加以下内容： ```cmake # 添加头文件搜索路径 include_directories(include) # 添加源文件 add_executable(module2 src/module2.cpp) # 暴露头文件 target_include_directories(module2 PUBLIC include) ``` 该 `CMakeLists.txt` 文件指定了 `module2` 子模块的构建规则，与 `module1` 子模块类似。 完成以上步骤后，我们可以使用以下命令来构建每个模块： ```bash cd module1 mkdir build cd build cmake .. make ``` ```bash cd module2 mkdir build cd build cmake .. make ``` 这些命令将进入每个模块的目录，创建一个新的构建目录，并使用相应的 CMakeLists.txt 文件来构建和编译可执行文件。 这就是如何使用多个 CMakeLists.txt 文件来管理 C++ 多文件项目并使每个模块都可以单独编译运行的示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值