前段时间, 突然产生了以 C++23 模块化为基础, 实现一个现代 C++模块化项目的构建工具。并以其能用自己从源码构建出自己也就是所谓的自举来做为初步目标, 目前这个目标已经实现

欢迎对现代 C++和模块化感兴趣的朋友来用, mcpp 构建工具使用模块化特性 玩一玩或开发开发小项目 也欢迎大家来反馈和交流

开源仓库: https://github.com/mcpp-community/mcpp

mcpp

一个 现代 C++ 模块化构建工具 — 纯 C++23 模块编写，已实现自举

核心特性

• C++23 模块原生支持 — import std 自动处理，文件级增量构建，模块依赖自动分析，零手动配置
• 纯模块化自举 — mcpp 自身由 43+ 个 C++23 模块组成，用自己构建自己，模块系统经实战验证
• 开箱即用 — 一条命令安装，内置 GCC 16 / LLVM 20 工具链，自动下载到隔离沙盒，不污染系统
• 集成依赖管理 — SemVer 约束解析、锁文件、跨项目 BMI 缓存、自定义包索引
• 多包工作空间 — Workspace 统一锁文件与版本管理，适合大型项目

为什么选择 mcpp ?

mcpp 专门为 C++23 模块化开发 打造。如果你想在项目中使用 import std、模块接口单元（.cppm）、模块分区等现代 C++ 特性，mcpp 在 Linux 上能为你提供便捷且友好的开发体验：

• 默认模块化 — mcpp new 创建的项目模板直接使用 C++23 模块，import std 开箱即用
• 文件级增量构建 — 基于 P1689 dyndep 的三层优化（前端脏检查 + 逐文件扫描 + BMI restat ），只重编真正变化的模块
• 一键创建 & 构建 — mcpp new hello && cd hello && mcpp build，工具链自动安装，无需手动配置编译器和构建系统
• 模块化生态 — mcpplibs 提供一系列可直接 import 的 C++ 模块化库，支持自定义包索引

注: 早期版本 — mcpp 仍在积极开发中，接口和行为可能在后续版本调整。
欢迎对现代 C++ 模块化构建工具感兴趣的开发者参与贡献。
问题 / 反馈 / 想法欢迎在 issues 留言。

快速开始

安装

方式一：使用 xlings 安装（推荐）

xlings install mcpp -y

方式二：一键安装脚本

curl -fsSL https://github.com/mcpp-community/mcpp/releases/latest/download/install.sh | bash

安装到 ~/.mcpp/，自动加进 shell PATH 。删除 ~/.mcpp 即可干净卸载。

方式三：让 AI 助手帮你安装

将以下提示词复制给你的 AI 编码助手（ Claude Code / Cursor / Copilot 等）：

阅读 https://github.com/mcpp-community/mcpp 的 README ，
帮我安装 mcpp 并创建一个 C++23 模块项目，构建并运行。
项目的 .agents/skills/mcpp-usage/SKILL.md 有详细的使用指南。

创建项目 & 构建运行

mcpp new hello
cd hello
mcpp build
mcpp run

注：首次构建会初始化环境并获取工具链，可能需要一些时间。

项目结构

hello/
├── mcpp.toml             ← 工程描述
└── src/
    └── main.cpp          ← import std; 直接可用

# mcpp.toml
[package]
name = "hello"

[targets.hello]
kind = "bin"
main = "src/main.cpp"

使用模块化库

在 mcpp.toml 中添加两行依赖，即可引用 mcpplibs 社区模块化库：

[dependencies]
cmdline = "0.0.2"

然后在代码中直接 import：

import mcpplibs.cmdline;

更多依赖配置方式（版本约束、命名空间、Git 引用、本地路径等）参见 mcpp.toml 指南 — 依赖管理。

平台支持

OS / arch	GCC (glibc)	GCC (musl)	Clang / LLVM	MSVC
Linux x86_64		默认		—
Linux aarch64				—
macOS	—	—		—
Windows	—	—

已支持 ｜ 计划中

默认：release 二进制走 musl 全静态，Linux x86_64 可直接运行，无 glibc 依赖。

文档

• 快速开始 — 5 分钟完成 install → new → build → run
• 示例项目
• 发布打包
• 工具链管理
• 从源码构建
• mcpp.toml 指南
• 工作空间

任意命令的完整选项可通过 mcpp <cmd> --help 查阅。

AI 辅助学习：你可以将以下提示词发给 AI 编码助手，让它帮你快速了解 mcpp：

阅读 https://github.com/mcpp-community/mcpp 仓库的
.agents/skills/mcpp-usage/SKILL.md 和 docs/ 目录下的文档，
告诉我如何用 mcpp 创建一个带依赖的 C++23 模块项目。

参与贡献

欢迎通过 Issue 和 PR 参与项目开发。项目接受开发者使用 AI Agent 参与开发与贡献。

基本流程

1. 创建 Issue — Bug 修复、新功能、优化等，先在 issues 创建讨论
2. 实现改动 — Fork 仓库，创建分支，实现并验证（mcpp build + E2E 测试）
3. 提交 PR — 使用 gh pr create，确保 CI 通过
4. CI 必须通过 — CI 不通过的 PR 不会被合入

提交信息规范：feat: / fix: / test: / docs: / refactor: 前缀

AI Agent 贡献：项目的 .agents/skills/mcpp-contributing/SKILL.md 提供了完整的 Agent 贡献流程和项目结构说明。将以下提示词发给 AI 助手即可：

阅读 https://github.com/mcpp-community/mcpp 仓库的
.agents/skills/mcpp-contributing/SKILL.md ，
按照指南帮我给 mcpp 项目提交一个贡献。

社区 & 生态

• 社区论坛 — 交流群 (Q: 1067245099)
• mcpp-index — 默认包索引
• mcpplibs — 模块化 C++ 库集合

致谢

项目依赖和灵感来源：

• xlings — 工具链 / 包管理底座
• mcpplibs.cmdline — CLI 框架
• ninja — 底层构建引擎
• xmake — 跨平台构建工具
• cargo — Rust 包管理器

从去年发布GCC 15.1 并支持 import std开始, 我的新项目也全面转向C++23 + 模块化 (踩了不少坑 [逃]). 而最近几天 GCC 16.1 也正式发布了, 这篇文章就来初步的上手体验一下.

主要内容包括:

• 0.GCC 16 环境配置
• 1.默认标准: 从C++17升级到C++20, 正式进入C++2x时代
• 2.模块化: 有一定优化, 但任处于实验性支持阶段 (悲)
• 3.代码诊断和静态分析增强
• 4.C++ 26 反射实验性支持
• 5.总结及相关链接

0. 环境配置 (Linux)

安装GCC 16可以选择按官方文档从源码进行构建 GCC WIKI 或 直接使用xlings工具安装预构建版本(注: 该方式有个好处不污染系统环境)

安装xlings包管理工具

curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/refs/heads/main/tools/other/quick_install.sh | bash
source ~/.bashrc # 或重新打开一次控制台
xlings -h

xlings工具安装后, 创建隔离环境并安装gcc 16

xlings subos new gcc-test
xlings subos use gcc-test
xlings install gcc@16.1.0 -y
gcc --version

1.默认标准: 从 C++17 升级到 C++20, 正式进入 C++2x 时代

GCC 16 的一个关键变化是: C++ 编译默认标准从 GNU++17 变成 GNU++20。不用额外再写 -std=c++20 也能编译下面的程序了:

#include <iostream>

consteval int answer() {
    return 16;
}

int main() {
    std::cout << "__cplusplus=" << __cplusplus
              << ", consteval=" << answer() << '\n';
}

编译运行:

g++ cpp20-default.cpp -o cpp20-default
./cpp20-default

输出:

__cplusplus=202002, consteval=16

如果显式退回 C++17:

g++ -std=c++17 cpp20-default.cpp -o cpp17-check

会报错:

t.cpp:3:1: error: 'consteval' does not name a type; did you mean 'constexpr'?
    3 | consteval int answer() {
      | ^~~~~~~~~
      | constexpr

默认标准的改变, 不仅仅只是帮我们省了-std=c++20，而是默认构建行为的改变 会加速C++ 2x时代生态的发展

2.模块化: 有一定优化, 但任处于实验性支持阶段

模块化早在C++20就发布, 他的目标是想解决 C++ 头文件模型长期存在的问题: 重复解析、宏污染、包含顺序敏感、接口和实现边界不够清晰。在工程方面他对C++的影响是颠覆性的, 但是由于历史/兼容性/复杂度等多方面原因导致, GCC 16 的默认标准虽然是 GNU++20，但 modules 支持仍然是实验性的，所以GCC 16对模块化爱好者来说只能算波澜不惊

只不过, GCC16 还是有在模块化做了一些工作的

• 修复了一些模块化的bug
• 新增 --compile-std-module，用于更方便地构建标准库相关模块和 header unit

其中 --compile-std-module 的增加 更方便大家体验模块化和import std, 避免了之前连一个hello world级别的main.cpp编译都要分几步的情况(有时候还有问题), 所以这也算是一大进步 - 现在可以像下面一样一键编译 import std 的程序了

// main.cpp
import std;

int main() {
    std::println("{}", 42);
}

编译:

g++ -std=c++23 -fmodules --compile-std-module main.cpp -o app
./app

3. 诊断增强: 错误信息结构化 + 编译期静态代码分析

C++ 报错经常被吐槽，不是因为编译器不知道哪里错了，而是因为错误链太长，人很难从一堆候选函数、模板实例化和类型展开里看出主线。

GCC 16 的一个明显变化是，部分 C++ 错误信息开始用层级结构展示。例如这个声明和定义不一致的例子:

class Foo {
public:
    void test(int i, int j, void *ptr, int k);
};

void Foo::test(int i, int j, const void *ptr, int k) {
}

int main() {
    return 0;
}

编译:

g++ diagnostics-mismatch.cpp

GCC 16 会把候选函数和参数差异分层展示，核心信息大致是:

error: no declaration matches 'void Foo::test(int, int, const void*, int)'
  - there is 1 candidate
    - candidate is: 'void Foo::test(int, int, void*, int)'
      - parameter 3 of candidate has type 'void*'
      - which does not match type 'const void*'

这比以前只告诉你 找不到匹配声明 更有用，它一定程度指出了候选是谁、哪里不一致、哪一个参数出了问题。

甚至还能生成更适合浏览器查看的诊断html页面:

g++ diagnostics-mismatch.cpp \
  -fdiagnostics-add-output=experimental-html

如果想给 CI、IDE 或代码扫描平台使用，可以生成 SARIF:

g++ diagnostics-mismatch.cpp \
  -fdiagnostics-format=sarif 

这个的优化, 不仅 报错更容易看了，而且后面可能会影响工具链体验。编译器不再只是把错误打印到终端，而是可以把结构化诊断交给网页、编辑器、代码审查和静态分析系统。

配合上 -fanalyzer 的能力。它是 GCC 自带的静态分析能力。如果加上 -Werror 体验就有点类似Rust的严格编译期检查功能

看一个 use-after-delete:

#include <iostream>

int main() {
    int *p = new int(42);
    delete p;
    std::cout << *p << "\n";
}

编译:

g++ -std=c++20 -fanalyzer analyzer-uaf.cpp

GCC 16 会给出类似警告:

warning: use after 'delete' of 'p' [CWE-416] [-Wanalyzer-use-after-free]

4. C++26 特性: Reflection / 反射

GCC 16 实现了若干 C++26 特性，这里简单试一试

-std=c++26 -freflection

以一个简单的结构体为例, 看看 C++26反射 的功能:

#include <iostream>
#include <meta>
#include <string_view>

struct User {
    int id;
    double score;
};

consteval std::size_t field_count() {
    auto fields = std::meta::nonstatic_data_members_of(
        ^^User,
        std::meta::access_context::unchecked()
    );
    return fields.size();
}

consteval std::string_view field_name(std::size_t index) {
    auto fields = std::meta::nonstatic_data_members_of(
        ^^User,
        std::meta::access_context::unchecked()
    );
    return std::meta::identifier_of(fields[index]);
}

consteval std::string_view field_type(std::size_t index) {
    auto fields = std::meta::nonstatic_data_members_of(
        ^^User,
        std::meta::access_context::unchecked()
    );
    return std::meta::display_string_of(std::meta::type_of(fields[index]));
}

int main() {
    constexpr auto type_name = std::meta::display_string_of(^^User);

    std::cout << type_name << " has " << field_count() << " fields\n";
    std::cout << field_name(0) << ": " << field_type(0) << '\n';
    std::cout << field_name(1) << ": " << field_type(1) << '\n';
}

编译运行:

g++ -std=c++26 -freflection reflection-user.cpp -o reflection-user
./reflection-user

输出:

User has 2 fields
id: int
score: double

这里的 ^^User 是对 User 这个结构体类型做静态反射，std::meta::display_string_of 可以拿到类型的显示名。std::meta::nonstatic_data_members_of 则能拿到结构体的非静态数据成员列表，再通过 identifier_of 和 type_of 分别取得成员名和成员类型。

C++ 代码可以在编译期拿到结构体自身的字段信息。这个功能对 序列化、ORM、RPC、命令行参数解析、UI 绑定、测试生成等大量现在依赖宏、模板技巧或外部代码生成的场景 有重要影响

5. 总结

GCC 16.1.0 感觉最核心的就是默认标准从C++17变成了C++20, 某种意义上也算正式迈入C++2x时代了, 下面是一些个人感觉

• 1.默认 C++ 标准从 GNU++17 变成 GNU++20。能进一步加速C++生态进入C++2x的时代
• 2.C++20 modules特性 在 GCC 16 里只是做了部分优化, 相比GCC 15.1.0引入import std来说, 没有特别惊喜
• 3.诊断输出更结构化了。嵌套错误、HTML、SARIF 会让编译器错误更适合教学、CI 和 IDE 集成。
• 4.C++26 Reflection 已经可以初步尝试。对于个人项目可以上手用一用 (但可能存在很多潜在的坑)

我个人是比较关注模块化的进展, 总体来说GCC16虽然模块化特性上没有过多惊喜, 但在import std之后, 模块化算是已经初步可以在项目里尝试的水平了, 并且我们 mcpp-community 现代C++爱好者社区 已经在 模块化的 项目/库的 工程化、包管理、工具链 等方面有一定的探索, 欢迎感兴趣的朋友加入讨论

• 社区Github主页: https://github.com/mcpp-community
• C++23模块化项目: https://github.com/openxlings/xlings
• C++23模块化库: https://github.com/mcpplibs

相关链接

• xlings: https://github.com/openxlings/xlings
• mcpp-community: https://github.com/mcpp-community
• GCC 16.1 Released: https://gcc.gnu.org/pipermail/gcc-announce/2026/000190.html
• GCC 16 Release Series: Changes, New Features, and Fixes: https://gcc.gnu.org/gcc-16/changes.html
• GCC 16.1.0: https://sourceware.org/pub/gcc/releases/gcc-16.1.0/

欢迎大家在这里交流、讨论、反馈

• https://github.com/mcpp-community/mcpp-style-ref

image.png

• 价格: 免费
• 开发者: Sunrisepeak
• 发行商: MOGA
• 发行时间: 预计2025年10月
• 游戏体量: 100H - 200H之间
• 标签: 类魂系列、模拟人生、Online、程序员、C++、开源、费曼学习法

mcpp-standard开源项目简介

一个 强调动手实践 的 现代C++ 入门教程项目。以现代C++的核心语言特性为基础, 开发了一套 [Book + Video + Code + X] 结构的"现代"教程。其中:

• Book: 对应的是提供在线电子书和文档解析
• Video: 提供核心语言特性的讲解视频
• Code: 提供对应的代码练习及自动化检测工具(包括在线代码练习环境)
• X: 提供项目的社区论坛和交流讨论群组

项目的电子书、练习代码及相关工具开源在Github上, 视频发布在Bilibili和Youtube上

• 项目开源地址: https://github.com/Sunrisepeak/mcpp-standard
• 项目视频列表: bilibili / youtube

项目之前也被业内媒体 HelloGithub 收录和分享过(112期)

一、活动内容

活动以mcpp-standard项目现有的核心语言特性的学习和交互式的代码练习的完成为 主线剧情 , 并在过程中 玩家先扮演C++学习者, 学习相关的核心特性, 然后再扮演技术分享者 把学到的C++特性用自己的语言和逻辑在分享给其他人, 双重视角 + 费曼学习法来快速入门现代C++

同时活动也设置了 支线剧情 的玩法, 玩家在完成新手村任务(T0)后, 即可选择申请加入 活动小组, 然后就可以以团队协作的方式, 参与活动/社区/项目的开发和维护中, 感受一个开源项目和社区是如何运行的...

目标

• 基础目标
  • 初步的入门/了解现代C++
  • 使用mcpp-standard和cppreference持续学习的能力
  • 具备成为现代C++的技术分享者/布道者的初步能力(编写技术文章、制作教学视频...
  • 成为mcpp-standard项目的贡献者(至少合入一次PR
• 扩展目标(可选
  • 了解活动/开源项目和社区的开发和运营方法
  • 参与活动/项目/社区的维护和开发
  • 成为mcpp-standard项目和社区的核心贡献者/开发者

流程结构和玩法

活动整体设计了主线剧情 + 可选的支线剧情

• 核心玩法/主线: [学习现代C++核心特性 -> 把学到教会其他人 -> 参与社区讨论] 循环这个过程

• 活动的任务发布和活动基于Github项目看板进行管理和记录
• 虚线箭头表示可选路径, 详细介绍参考 -> MSCP | 流程结构详细介绍

二、如何参与和游玩 ?

由于活动涉及的项目/材料/工具内容, 几乎都是开源的, 所以理论任何人都可以参与该活动

• 从完成第一个任务开始
• 加入活动小组(可选)

::: tip

如果参与中遇到问题/困难, 可以 查看 常见问题 或 在论坛创建话题贴 -> mcpp论坛

注: 活动相关的文档/工具等资源可以查看 -> 活动地图

:::

三、社区

• mcpp论坛
• 活动工作流看板
• mcpp活动交流群: 1067245099
• MOGA交流群(可选): 1065632930

四、相关链接

• 活动地图
• 常见问题
• mcpp-standard项目开源仓库
• 活动工作流看板
• 活动记录

http://forum.d2learn.org/post/418

问题1: 界面乱码问题

A1: xlings已经更新解决(增加了utf8编码的支持, 重装即可

问题2: 代码输入光标位置问题

解决方法1: 代码中不要包含中文内容
解决方法2: 取消beta/utf8编码选项, 然后卸载重新安装devcpp

6c34d5cd-b1eb-4c7f-8181-1ca3ca6c673b-image.png

中/英文切换: https://forum.d2learn.org/topic/134

image.png

image.png

d2x update

PR: https://github.com/Sunrisepeak/mcpp-standard/pull/8

注: 需要更新到最新版本的xlings

先更新一下d2x工具

然后再到项目目录运行下面命令进入练习模式

注: 最新版本的d2x也支持配置AI大模型做智能引导, 也可以玩一玩

33e4df78-8646-4b89-847f-41899668b251-image.png

集合

书上的定义

集合是指具有某种特定性质的不同对象无序聚集成的一个整体。
集合中的每一个对象称为集合的元素；
通常用大写字母表示集合；
用小写字母表示集合中的元素。

也就是说把一些东西放到一起叫做集合(个人理解)

代码实现

#include <string>
#include <vector>
#include <stdint.h>
#include <iostream>

// 抽象基类，定义集合元素的基本接口
class elmBase
{
public:
    // 将元素转换为字节数组的纯虚函数（序列化基础）
    virtual std::vector<uint8_t> getUint8Array() const = 0;

    // 默认比较运算符，通过字节数组逐字节比较
    virtual int operator==(const elmBase &other)
    {
        std::vector<uint8_t> thisDate = getUint8Array();
        std::vector<uint8_t> otherDate = other.getUint8Array();
        if (thisDate.size() != otherDate.size())
            return 0;
        for (int i = 0; i < thisDate.size(); i++)
        {
            if (thisDate[i] != otherDate[i])
                return 0;
        }
        return 1;
    }

    // 转换为字符串表示的纯虚函数
    virtual std::string toString() = 0;

    // 虚析构函数确保正确释放派生类对象
    virtual ~elmBase()
    {
    }
};

// 特殊元素类型，始终返回比较不成立
class alwaysFalse : public elmBase
{
public:
    std::vector<uint8_t> getUint8Array() const override
    {
        return std::vector<uint8_t>(); // 返回空数组
    }

    std::string toString() override
    {
        return {}; // 返回空字符串
    }

    // 重载运算符始终返回false，用于占位符场景
    virtual int operator==(const elmBase &other) override
    {
        return 0;
    }
    ~alwaysFalse()
    {
    }
};

// 哈希表节点结构，使用链表法解决冲突
using elmNode = struct elmNode
{
    elmBase *elm;  // 元素指针
    elmNode *next; // 下一个节点指针
};

// 节点工厂函数，创建新节点并初始化元素
elmNode *elmNodeFactory(elmBase *elm)
{
    elmNode *newNode = new elmNode();
    newNode->elm = elm;
    newNode->next = nullptr;
    return newNode;
}

// 自定义集合类，基于哈希表实现
class set
{
private:
    uint32_t prime;   // 哈希表大小（通常选择质数）
    elmNode **setMap; // 哈希桶数组

    // 初始化哈希表结构
    void inline _init_(uint32_t prime)
    {
        this->prime = prime;
        this->setMap = new elmNode *[prime];
        // 初始化每个桶为alwaysFalse哨兵节点
        for (uint32_t i = 0; i < prime; ++i)
        {
            this->setMap[i] = elmNodeFactory(new alwaysFalse());
        }
    }

protected:
    // 查找元素对应的哈希桶
    elmNode **__find__(elmBase *elm)
    {
        uint32_t hash = rotatingHash(elm->getUint8Array(), this->prime);
        return &(this->setMap[hash]); // 返回桶的指针
    }

    /**
     * 通用链表操作函数
     * @param link 链表头指针的指针
     * @param elm 目标元素
     * @param cmp 自定义比较函数，返回true时停止遍历
     * @param finally 遍历结束后的处理函数（插入等操作）
     * @return 找到的节点或操作结果节点
     */
    elmNode *__link__(elmNode **link, elmBase *elm,
                      bool (*cmp)(elmNode *, elmBase *),
                      elmNode *(*finally)(elmNode **, elmNode *, elmBase *) = nullptr)
    {
        elmNode *linkPriv = *link;
        elmNode *linkCurrent = linkPriv;

        // 遍历链表查找元素
        while (linkCurrent != nullptr)
        {
            if (cmp(linkCurrent, elm))
            {
                return linkCurrent;
            }
            linkPriv = linkCurrent;
            linkCurrent = linkCurrent->next;
        }

        // 执行最终处理函数（如插入新节点）
        if (finally != nullptr)
        {
            return finally(link, linkPriv, elm);
        }
        return nullptr;
    }

public:
    // 构造函数初始化哈希表
    set(uint32_t prime) { _init_(prime); }
    ~set()
    {
        for (uint32_t i = 0; i < this->prime; ++i)
        {
            elmNode *link = this->setMap[i];
            while (link != nullptr)
            {
                elmNode *tmp = link;
                link = link->next;
                if (tmp != nullptr)
                {
                    if (tmp->elm != nullptr)
                    {
                        std::cout << "delete " << tmp->elm->toString() << std::endl;
                        delete tmp->elm;
                    }
                    delete tmp;
                }
            }
        }
    }
    // 旋转哈希算法实现
    static uint32_t rotatingHash(std::vector<uint8_t> key, uint32_t prime)
    {
        uint32_t hash = key.size();
        for (uint32_t i = 0; i < key.size(); ++i)
            hash = (hash << 4) ^ (hash >> 28) ^ (uint32_t)(key[i]);
        return (hash % prime);
    }

    // 添加元素到集合
    bool add(elmBase *elm, bool force = false)
    {
        elmNode **node = __find__(elm);
        auto finally = [](elmNode **node, elmNode *linkPriv, elmBase *elm) -> elmNode *
        {
            // 插入新节点到链表末尾
            if (linkPriv->next == nullptr)
            {
                linkPriv->next = elmNodeFactory(elm);
            }
            return nullptr;
        };

        // 使用lambda作为比较函数
        elmNode *targetNode = this->__link__(node, elm, [](elmNode *node, elmBase *tag) -> bool
                                             { return *(node->elm) == *tag; }, finally);

        return targetNode == nullptr; // 返回是否插入成功
    }

    // 检查元素是否存在
    bool get(elmBase *elm)
    {
        elmNode **node = __find__(elm);
        elmNode *targetNode = this->__link__(node, elm,
                                             [](elmNode *node, elmBase *tag) -> bool
                                             {
                                                 return *(node->elm) == *tag;
                                             });
        return targetNode != nullptr;
    }

    // 移除集合中的元素
    bool remove(elmBase *elm)
    {
        elmNode **node = __find__(elm);
        elmNode *ret = this->__link__(node, elm,
                                      [](elmNode *current, elmBase *tag) -> bool
                                      {
                                          // 查找前驱节点执行删除
                                          if (current->next != nullptr && *(current->next->elm) == *tag)
                                          {
                                              elmNode *tmp = current->next;
                                              current->next = current->next->next;
                                              delete tmp->elm; // 释放元素内存
                                              delete tmp;      // 释放节点内存
                                              return true;
                                          }
                                          return false;
                                      });
        return ret != nullptr;
    }

    // 调试用打印函数，显示哈希表结构
    void print()
    {
        std::cout << "[HashTable Structure]" << std::endl;
        for (int i = 0; i < this->prime; i++)
        {
            std::cout << "Bucket " << i << ": ";
            elmNode *node = this->setMap[i];
            while (node != nullptr)
            {
                std::cout << node->elm->toString() << " -> ";
                node = node->next;
            }
            std::cout << "NULL" << std::endl;
        }
    }
};

// 数值类型元素实现
class number : public elmBase
{
    int data;

public:
    number(int data) : data(data) {}

    std::vector<uint8_t> getUint8Array() const override
    {
        // 将整型转换为字节数组
        return std::vector<uint8_t>(
            reinterpret_cast<const uint8_t *>(&data),
            reinterpret_cast<const uint8_t *>(&data) + sizeof(data));
    }

    std::string toString() override
    {
        return std::to_string(data);
    }
    ~number()
    {
    }
};

// 字符串类型元素实现
class string : public elmBase
{
    std::string data;

public:
    string(std::string data) : data(data) {}

    std::vector<uint8_t> getUint8Array() const override
    {
        // 将字符串内容转换为字节数组
        return std::vector<uint8_t>(data.begin(), data.end());
    }

    std::string toString() override
    {
        return data;
    }
    ~string()
    {
    }
};

集合与元素的关系

若A表示一个集合，a是集合A中的元素，记作aA，读作a属于A；
若a不是集合A中的元素，则记作aA，读作a不属于A。

未完待续

image.png

代码仓库: https://github.com/Sunrisepeak/mcpp-standard