首页 › C/C++论坛 › C23和C++26的#embed嵌入资源指南

东皓 發表於 2025-7-14 10:09:00

C23和C++26的#embed嵌入资源指南

<p>c++26最近刚敲定标准，新增了许多重量级特性。</p>
<p>不过目前能实际上手测试的特性不多，毕竟标准刚刚确定，比较大的变更里只有“资源嵌入”或者用标准文档里英文名“resource inclusion”这个新特性可以尝鲜。</p>
<p>虽然这篇文章标题叫指南，但实际上更像实验记录，而且现在属于早期阶段编译器对资源嵌入的处理有可能会有改变（不过语法不会改了），所以把这篇文章当教程看也行但得注意文章内容与实际使用上可能存在差别。</p>
<p>测试环境：</p>
<ul>
<li>操作系统：macOS 15 和 Fedora 42</li>
<li>编译器：GCC 15.1</li>
<li>测试文本数据编码：UTF-8</li>
</ul>
<p>网站上显示GCC15是完全支持<code>#embed</code>资源嵌入的，本来还想测试一下clang20，遗憾的是gcc测下来还有点小bug，况且clang在网站上显示只支持部分embed功能，因此我就不蹚雷了。</p>
<p>准备好环境之后我们来了解一下基础语法。</p>
<h2 id="为什么需要embed">为什么需要embed</h2>
<p>把数据嵌入到代码里有不少好处，比如：</p>
<ol>
<li>部署更简单，不需要额外捆绑资源文件</li>
<li>程序可以更健壮，无需额外处理资源文件缺失或数据读取失败等意外情况</li>
<li>能避免一些权限问题，一些系统上对文件的存放和读写有比较严格的限制</li>
</ol>
<p>市面上也有很多工具可以完成资源/数据的嵌入，有些工具还提供灵活的数据查找功能，比如Qt的rcc。但这些工具一直有如下几个缺点：</p>
<ol>
<li>需要安装额外工具。这会增加项目的复杂性和管理成本，比如如何在CI里使用这些工具</li>
<li>显著增加代码体积。众所周知二进制数据很难直接原样放进文本格式的代码里，所以要么对数据序列化要么对数据进行编码（比如base64），不管那种都会让二进制数据体积膨胀</li>
<li>学习成本高。市面上的工具用法看似类似，实则差异明显，导致工具A的经验在工具B或C中难以通用</li>
</ol>
<p>因此我们需要一种易学、通用、无需额外编解码或序列化即可嵌入二进制数据的方案。于是<code>#embed</code>就诞生了。</p>
<p>在正式进入C++26的embed提案里有一组性能对比测试，我们只看GCC相关的：</p>
<p>执行速度：</p>
<table>
<thead>
<tr>
<th>Strategy</th>
<th>40 KB</th>
<th>400 KB</th>
<th>4 MB</th>
<th>40 MB</th>
</tr>
</thead>
<tbody>
<tr>
<td>#embed GCC</td>
<td>0.236 s</td>
<td>0.231 s</td>
<td>0.300 s</td>
<td>1.069 s</td>
</tr>
<tr>
<td>xxd-generated GCC</td>
<td>0.406 s</td>
<td>2.135 s</td>
<td>23.567 s</td>
<td>225.290 s</td>
</tr>
</tbody>
</table>
<p>内存占用：</p>
<table>
<thead>
<tr>
<th>Strategy</th>
<th>40 KB</th>
<th>400 KB</th>
<th>4 MB</th>
<th>40 MB</th>
</tr>
</thead>
<tbody>
<tr>
<td>#embed GCC</td>
<td>17.26 MB</td>
<td>17.96 MB</td>
<td>53.42 MB</td>
<td>341.72 MB</td>
</tr>
<tr>
<td>xxd-generated GCC</td>
<td>24.85 MB</td>
<td>134.34 MB</td>
<td>1,347.00 MB</td>
<td>12,622.00 MB</td>
</tr>
</tbody>
</table>
<p>看着相当不错。美中不足的是缺少可执行文件体积对比，这个在我们学完了embed的用法之后可以额外做个测试。</p>
<h2 id="基础语法">基础语法</h2>
<p>这次没有基础回顾环节，因为是全新的语法，直接学就完事了。</p>
<p>c和c++的embed语法形式差不多，所以放一起讲了。顺便我也不做标准文档的复读机，否则仅解释一个<code>pp-token</code>（预处理器可以接受的token）就可能占用大量篇幅，我会用简单的语言配上简单的例子做解释。</p>
<p>embed指令是预处理器的一种，语法如下：</p>
<pre><code class="language-c++"># embed &lt;header-name&gt;|"header-name" parameters... new-line
</code></pre>
<p><code>#embed</code>是指令名部分，这个很容易理解。</p>
<p><code>&lt;header-name&gt;|"header-name"</code>是要嵌入的资源文件的名字，正如其中“header name”所暗示的，嵌入的资源文件搜索路径和头文件一样，引号代表优先搜索当前目录之后搜索编译器的头文件目录；尖括号则表示只搜索编译器限定的头文件存放目录。嵌入资源文件还可以使用绝对路径，比如<code>#embed "/dev/urandom"</code>，注意要用引号。所以最基础的嵌入资源的语法是这样的：</p>
<pre><code class="language-c++">#embed &lt;my-data&gt; // linux GCC 会去/usr/include和通过-I参数传给编译器的目录下查找有没有一个叫 my-data 的文件

#embed "data1.bin" // 先在源文件所在的当前目录下寻找 data1.bin，找不到则去编译器的搜索路径里查找
</code></pre>
<p><code>parameters...</code>是一组形式类似<code>选项A 选项B</code>或者<code>选项A(参数1) 选项B(参数1, 参数2, ...)</code>的东西，学名叫<code>embed-parameter</code>，中译名还没有，暂且就叫嵌入参数好了。嵌入参数主要用于给嵌入的资源做一些限制或者添加某些属性，后面会单独开一节内容细讲。嵌入参数也可以有自己的参数，这些参数必须是编译期常量。比如：</p>
<pre><code class="language-c++">#embed "data1.bin" limit(32) // limit是embed-parameters之一，用于限制数据长度

#embed &lt;data-1&gt; if_empty(0) // 如果文件是空的，则用0来替代嵌入内容
</code></pre>
<p>嵌入参数目前只有标准规定的几个可以用，但c++在这里做了扩展，允许编译器自己实现一些<code>parameters</code>，语法形式是<code>A::B</code>或者带参数的<code>A::B(...)</code>。</p>
<p><code>new-line</code>就不需要我多解释了吧，就和宏定义一样每一个<code>#embed</code>指令都以换行符结束，如果指令很长想拆分到多行，也需要像<code>#define</code>一样使用反斜杠<code>\</code>。</p>
<p>另外从资源文件名开始到各种<code>parameters</code>的位置上都可以使用宏，预处理器会进行宏展开，举个例子：</p>
<pre><code class="language-c++">#define FILE_NAME "data1.bin"
#define DATA_LEN 32
#define PARAM1 limit
#define PARAM2 limit(LEN)

constexpr unsigned char data1[] = {
#embed "data1.bin" limit(32) // 从data1.bin读一定长度的数据进来
}

constexpr unsigned char data2[] = {
#embed FILE_NAME limit(32) // 和上面data1等价，但文件名用了宏
}

constexpr unsigned char data3[] = {
#embed FILE_NAME PARAM1(32) // 等价，parameter用了宏，但参数没有
}

constexpr unsigned char data4[] = {
#embed FILE_NAME PARAM2 // 等价，parameter和参数都依赖宏替换
}
</code></pre>
<p>现在看不懂也没关系，只要知道宏展开和替换也会在<code>#embed</code>中进行就够了。</p>
<p>编译代码需要使用<code>gcc -std=c23</code>以及<code>g++ -std=c++26</code>，否则会报错。</p>
<p>和<code>#include</code>一样，如果文件不存在或者不能正常读取的话编译器会报错。</p>
<h2 id="embed的工作原理">embed的工作原理</h2>
<p>到目前为止，我们还不知道 embed 会做什么，也不清楚如何使用。本节先带你了解 embed 的工作原理，下一节再讲具体用法。</p>
<p>在这之前需要了解两个新概念和一个旧知识点。</p>
<p>第一个新概念是<code>implementation-resource-width</code>，我叫它资源宽度，单位是bit，没错是“位”。它表示要嵌入的资源一共有多少“位”，恐怕没多少人会这么计算文件大小，不过标准是有意为之的。</p>
<p>第二个要了解的是旧知识点，<code>CHAR_BIT</code>，这是一个宏，在头文件<code>&lt;climits&gt;/&lt;limits.h&gt;</code>里，代表当前环境上一个“字节byte”有多少“位bit”。比如在macOS和linux上gcc给出的<code>CHAR_BIT</code>值都是8，代表在这些平台上至少在c/c++代码中一个字节有8位。现代的主流平台几乎都是8位一字节，但过去并不是这样，而且总有些奇妙的嵌入式环境会打破这一常识。</p>
<p>最后一个概念是<code>resource-count</code>，计算公式是<code>implementation-resource-width / CHAR_BIT</code>，或者是嵌入参数<code>limit</code>中指定的那个值。这个值必须是整数。这个东西起个像样的中文名很难，但也暂且允许我叫它资源长度吧。</p>
<p>如果资源长度不是整数，比如你的资源宽度是32位，但<code>CHAR_BIT</code>的值不巧是7，那么编译会报错。遗憾的是我手上没这种设备，所以报错就不演示了。</p>
<p>这三个概念说了半天有什么用？答案是这和embed的工作原理有关：<strong><code>#embed</code>会把资源文件的内容替换成<code>resource-count</code>个整数字面量，这些字面量之间以半角逗号分隔</strong>。</p>
<p>以c语言为例，c++也差不多：</p>
<pre><code class="language-c">#include &lt;stdio.h&gt;

int main()
{
    const unsigned char text[] = {
      #embed "data1.txt"
      , 0
    };
    printf("embed: %s\n", text);
}

// 下面是data1.txt的内容：
// Hello! こんにちは、你好
</code></pre>
<p>可以算一下文件的资源宽度，在utf8下英语字母和半角标点还有空格是1字节，汉字、日语片假名和全角标点是3字节，所以资源一共有31字节，换算一下资源长度也正好是31。</p>
<p>我们可以用<code>gcc -std=c23 -E main.c</code>来查看完成预处理的源代码文件：</p>
<pre><code class="language-console">
......
# 3 "main.c"
int main()
{
    const unsigned char text[] = {
               72,101,108,108,111,33,32,227,129,147,227,130,147,227,129,171,227,129,161,227,129,175,227,128,129,228,189,160,229,165,189,10
      , 0
    };
    printf("embed: %s\n", text);
}
</code></pre>
<p>输出会非常长，所以我截取了有用的部分。这样看很明显，<code>#embed "data1.txt"</code>被替换成了<code>72,101,108,108,111,33,32,227,129,147,227,130,147,227,129,171,227,129,161,227,129,175,227,128,129,228,189,160,229,165,189,10</code>，数一数正好31个整数字面量。</p>
<p>而且可以看到前六个整数正好是<code>Hello!</code>每个字符对应的ASCII码。因为把数据转换成整数字面的过程类似于运行时不断调用<code>std::fgetc</code>，然后再将结果转换成整数字面量。也就是说如果你用<code>fopen("data1.txt", "rb")</code>在运行时打开资源文件，然后循环调用<code>fgetc</code>，会得到和<code>#embed</code>替换后一样的整数序列。c++里规定了必须是<code>int</code>类型的字面量，而c里只要求类型能完全兼容<code>unsigned char</code>即可，不过看上去GCC两边替换后的内容没什么区别。</p>
<p>如果embed发现给出的文件是空的，那么什么也不会生成，预处理器并不进行c++的语法检查，如果预期有数据的地方在替换完成后什么东西都没有，那编译的时候有可能爆出非常难以理解的错误，所以要注意处理这种情况。</p>
<p>这就是embed全部的工作原理。简单地说：资源文件的二进制数据 -&gt; 用与fgetc相同的规则转换成一个逗号分隔的整数字面量序列。</p>
<p>顺带一提c和c++的整数字面量只有0和范围内的正整数，没有负数，所以如果想用字符类型接这些嵌入数据的话，最好使用<code>unsigned char</code>，这也是c标准里要求替换出来的字面量的类型要兼容<code>unsigned char</code>的原因之一。</p>
<p>另一种不标准但简单的理解是：想象资源文件是一个有n个bit的连续的二进制数据流，从数据流的开始处每次取<code>CHAR_BIT</code>个bit，然后把这些bit整体转换成一个符合规则要求的整数字面量，转换完成后按顺序接着处理下面<code>CHAR_BIT</code>个bit，循环这一过程直到资源文件处理完成或者循环次数达到limit的限制。循环结束后一样会得到一个以逗号分隔的整数数列。</p>
<p>如果觉得文字描述比较抽象，这里还有图解：</p>
<p><img src="https://img2024.cnblogs.com/blog/1434464/202507/1434464-20250714100601468-1815732577.jpg" alt="embed-processing" loading="lazy"></p>
<h2 id="embed参数">embed参数</h2>
<p>在弄清楚了embed是如何处理嵌入数据的之后，我们再来看看嵌入参数。</p>
<p><code>#embed</code>负责把指定的数据源转换成整数字面量序列，而embed参数则对这些整数字面量序列产生影响。</p>
<p>每种参数都有不同的效果，有些可以在序列开头结尾添加内容，有的可以限制序列长度，还有的可以在序列为空时做特殊处理，不一而足。参数之间还可以组合发挥效力。每个参数自身只能在同一条<code>#embed</code>指令中出现一次。</p>
<p>下面我们来看看这些参数的具体功能和用法。</p>
<h3 id="limit">limit</h3>
<p>语法：<code>#embed "data" limit(预处理器能识别出来的数字常量)</code></p>
<p>limit顾名思义就是用来限制整数字面量序列长度的。</p>
<p>必须给limit一个0或者正整数参数。例子：</p>
<pre><code class="language-c">#define LENGTH 4
int main()
{
    const unsigned char text1[] = {
      #embed "data.txt" limit(2)
      , 0
    };
    const unsigned char text2[] = {
      #embed "data.txt" limit(LENGTH)
      , 0
    };
    printf("embed: %s\n", text1); // 输出：He
    printf("embed: %s\n", text2); // 输出：Hell
}
</code></pre>
<p>参数也可以是表达式，比如<code>limit(1+1)</code>，但不可以出现<code>#define</code>。</p>
<p>当输入参数为0时，embed会产生空序列，而输入负数会产生编译错误：<code>error: negative embed parameter operand</code>。</p>
<p>如果输入参数的值大于嵌入数据的<code>resource count</code>，标准要求预处理器把输入值改为<code>resource count</code>，相当于<code>std::min(resource-count, limit-operand)</code>。</p>
<p>在c语言中limit还有一个别名叫<code>__limit__</code>。</p>
<h3 id="prefix">prefix</h3>
<p>语法：<code>#embed "data" prefix(token序列)</code></p>
<p>token序列是一个或多个符合语法的预处理器token的组合，后面讲的<code>suffix</code>和<code>if_empty</code>的参数形式与此相同。通俗地说只要括号里的东西预处理器可以正常识别，那么就可以作为prefix的参数。</p>
<p>如果<code>prefix</code>的括号里是空的，则什么都不会做，否则会把括号里的token序列添加到整数序列的最前面。要注意的是它是把括号内的内容原样复制黏贴上去的，因此你需要在最后一个token后面加上逗号或者其他符号让整个处理后的序列符合c/c++语法规则，举个例子：</p>
<pre><code class="language-c">// data.txt内容：Hello

#define ALPHABET 't'
int main()
{
    const unsigned char text1[] = {
      #embed "data.txt" prefix(1+)
      , 0
    };
    const unsigned char text2[] = {
      #embed "data.txt" prefix(ALPHABET, 'e', 's', ALPHABET, 0x20, )
      , 0
    };
    printf("embed: %s\n", text1); // 输出：Iello
    printf("embed: %s\n", text2); // 输出：test Hello
}
</code></pre>
<p>其中<code>#embed "data.txt" prefix(1+)</code>被替换为<code>1+72, 101, 108, 108, 111</code>；而<code>#embed "data.txt" prefix(ALPHABET, 'e', 's', ALPHABET, 0x20, )</code>替换成了<code>'t', 'e', 's', 't', 0x20, 72, 101, 108, 108, 111</code>。</p>
<p>如果序列本身是空的，则<code>prefix</code>不生效。</p>
<p>prefix通常用于在embed进来的数据前加一些标记，因此参数多是一个或多个字符/整数常量，但如例子所示，任何合法的表达式也可以作为参数。</p>
<p>在c语言中prefix还有一个别名叫<code>__prefix__</code>。</p>
<h3 id="suffix">suffix</h3>
<p>语法：<code>#embed "data" suffix(token序列)</code></p>
<p><code>suffix</code>是<code>prefix</code>的对称操作，它会把token序列原样添加到整数序列的尾部。看个例子：</p>
<pre><code class="language-c">// data.txt内容：Hello

#define ALPHABET 't'
int main()
{
    const unsigned char text1[] = {
      #embed "data.txt" suffix(, 0) // 注意那个逗号，字符串以\x00结尾
    };
    const unsigned char text2[] = {
      #embed "data.txt" suffix(-10, 0x20, ALPHABET, 'e', 's', ALPHABET,)
      0 // 注意0前面没有逗号了
    };
    printf("embed: %s\n", text1); // 输出：Hello
    printf("embed: %s\n", text2); // 输出：Helle test
}
</code></pre>
<p>和prefix一样，如果整数字面量序列是空的，则什么也不做。</p>
<p>c语言中还可以使用它的别名<code>__suffix__</code>。</p>
<h3 id="if_empty">if_empty</h3>
<p>语法：<code>#embed "data" if_empty(token序列)</code></p>
<p>如果嵌入的整数序列为空（资源不存在或者通过<code>limit(0)</code>使得序列长度为0），则会用括号内的内容替换整条embed指令，否则不生效。</p>
<p>看示例代码辅助理解：</p>
<pre><code class="language-c">// data.txt内容：Hello
// data2.txt长度为0

int main()
{
    const unsigned char text1[] = {
      #embed "data.txt" if_empty('e', 'm', 'p', 't', 'y')
      , 0
    };
    const unsigned char text2[] = {
      #embed "data2.txt" if_empty('e', 'm', 'p', 't', 'y')
      , 0
    };
    const unsigned char text3[] = {
      #embed "data.txt" limit(0) if_empty('e', 'm', 'p', 't', 'y')
      , 0
    };
    printf("embed: %s\n", text1); // 输出：Hello，因为data.txt里有内容，所以if_empty不生效
    printf("embed: %s\n", text2); // 输出：empty，因为data2.txt里没有数据
    printf("embed: %s\n", text3); // 输出：empty，因为limit(0)使得整数序列为空
}
</code></pre>
<p>c语言中if_empty的别名是<code>__if_empty__</code>。</p>
<h2 id="__has_embed">__has_embed</h2>
<p><code>__has_embed</code>用来检查embed指令是否有效以及嵌入的资源是否为空。它的语法形式是：<code>__has_embed(&lt;header-name&gt;|"header-name" parameters...)</code>。</p>
<p>其实就是把embed指令中的换行符和<code>#embed</code>去掉，其余部分放进括号里。</p>
<p>如果资源能正常嵌入且不为空，<code>__has_embed</code>返回<code>__STDC_EMBED_FOUND__</code>；如果资源正常嵌入但是空的，返回<code>__STDC_EMBED_EMPTY__</code>；其余情况返回<code>__STDC_EMBED_NOT_FOUND__</code>。</p>
<p><code>__has_embed</code>可以配合条件编译指令使用，比如：</p>
<pre><code class="language-cpp">#if __has_embed("data.txt" limit(2))
doing A
#else
doing B
#endif
</code></pre>
<p>不过要注意，<code>__has_embed</code>有TOCTOU问题，也就是说检测是否能嵌入和实际读取资源进行嵌入之间有时间间隔，可能会导致检测通过但实际执行嵌入时文件被改变导致不再满足前面的条件要求。c++的提案里说因为这个问题本来不想添加这个表达式，但考虑到c里已经有这个了，再加上存在同样问题的<code>__has_include</code>已经包含在c++里，所以考虑再三还是提供了<code>__has_embed</code>。</p>
<p>我的建议是尽量少用这个，<code>if_empty</code>可以料理一部分文件为空的情况，资源文件不存在或者无法访问更应该视为fatal error而不是采用一些迂回绕过手段掩盖问题。当然一切以实际需求为准，想利用TOCTOU进行攻击的操作难度很大，通常也不用过份担心。</p>
<h2 id="如何使用">如何使用</h2>
<p>现在我们知道了embed语法规则和控制它行为的方法，但除了embed会产生一串整数之外我们还不知道具体的用法。</p>
<p>其实用法也没啥好讲的——就把它当成一串整数构成的序列来用就行了。当然如果这么说的话那这篇指南就有点潦草了，所以我会列举几个常见的用法给大家做参考。由于embed指令配合参数可以生成各种各样奇形怪状的内容，我这罗列出来的肯定只是用法中的一小部分，但我还是得提醒一句，能力越大责任越大，不要滥用语言提供的功能。</p>
<p>第一种用法其实已经包含在例子里了，那就是把嵌入的数据存进<code>unsigned char</code>或者其他整数类型的数组里：</p>
<pre><code class="language-c++">const unsigned char text1[] = {
    #embed "data.txt" limit(3) // 数组长度自动推导，为3 + 1 = 4
    , 0
};
const unsigned char text2[] = {
    #embed "data2.txt" if_empty('e', 'm', 'p', 't', 'y')
    , 0
};
const unsigned char text3 = { // 只有五个字符能嵌入，剩下的部分会被0值初始化
    #embed "data.txt" limit(0) if_empty('e', 'm', 'p', 't', 'y')
};
</code></pre>
<p>在这种用法下，嵌入资源生成的整数序列只能小于等于数组的长度要求，大于的话会报错。这也是使用嵌入资源的常见形式，别的工具比如<code>xxd</code>或者<code>Qt rcc</code>也是这样组织被嵌入的数据的。</p>
<p>第二种用法是用来聚合初始化c++的聚合类型或者c的结构体：</p>
<pre><code class="language-c">typedef struct A {
    int a;
    int b;
    long long c;
    unsigned long d;
    unsigned char e;
} A;

int main()
{
    A a_obj = { #embed "data.txt" }; // 被替换为 { 72,101,108,108,111 }
}
</code></pre>
<p>与数组相同，这种使用方式整数序列中数字的数量必须小于等于字段的数量，否则是语法错误。</p>
<p>第三种用法是拿来做函数参数或者模板非类型参数，不知道你们看到整数序列时第一想法是什么，但我第一个冒出来的念头是这个形式和参数列表太像了。用法可以是：</p>
<pre><code class="language-cpp">template &lt;int... nums&gt;
void calcAvg()
{
    long sum = (... + nums);
    std::cout &lt;&lt; (sizeof...(nums) != 0 ? static_cast&lt;double&gt;(sum) / sizeof...(nums) : 0) &lt;&lt; '\n';
}

void avg(int count, ...)
{
    long sum = 0;
    va_list args;

    va_start(args, count);
   
    for (int i = 0; i &lt; count; i++) {
      sum += va_arg(args, int);
    }
   
    va_end(args);
   
    std::cout &lt;&lt; (count ? static_cast&lt;double&gt;(sum) / count : 0.0) &lt;&lt; '\n';
}

int main()
{
    calcAvg&lt;
      #embed "data.txt"
    &gt;();
    avg(5,
      #embed "data.txt"
    );
}
</code></pre>
<p>embed指令需要独占一行，所以要注意代码的格式。作为函数或者模板参数时，生成的整数序列元素数量必须等于要求的参数数量。这种做法已经有点偏向于杂耍了。</p>
<p>其他方式就不列举了，最常见的就是上面这几种。鉴于embed指令的灵活性，想必将来一定会出现很多体操式玩法吧。</p>
<h2 id="生成文件大小测试">生成文件大小测试</h2>
<p>提案里有使用嵌入资源程序的性能对比，但没有生成文件大小的数据。</p>
<p>对于现代软硬件环境来说，可执行程序稍微大点其实也没有多大影响，或者看看日益流行的Electron程序，打包了大半个浏览器进去大家还不是用得乐此不疲。但知道一点基础数据总是没坏处的，它可以让我们估算程序的最终大小，以便采取合理的打包部署策略。</p>
<p>测试程序以c编写，编译的时候会从<code>/dev/urandom</code>读取指定长度的随机数据，然后以16进制格式打印每一个字节，程序不会真的执行，我们只测试编译出来的文件大小：</p>
<pre><code class="language-c">#include &lt;stdio.h&gt;

int main()
{
    const unsigned char text[] = {
      #embed "/dev/urandom" limit(LEN)
    };
    printf("random: ");
    for (int i = 0; i &lt; sizeof(text); i++) {
      printf("%02x", text);
    }
    printf("\n");
}
</code></pre>
<p>测试用的编译器都是GCC 15.1，操作系统分别是macOS arm64和Linux x86_64。编译选项都是<code>gcc -std=c23 -Wall -O2 -DLEN=n</code>。下面是测试结果：</p>
<table>
<thead>
<tr>
<th>嵌入大小</th>
<th>40 KB</th>
<th>400 KB</th>
<th>4 MB</th>
<th>40 MB</th>
<th>400 MB</th>
</tr>
</thead>
<tbody>
<tr>
<td>Linux x86_64</td>
<td>70 KB</td>
<td>454 KB</td>
<td>4.07 MB</td>
<td>40.07 MB</td>
<td>400.07 MB</td>
</tr>
<tr>
<td>macOS arm64</td>
<td>65 KB</td>
<td>436 KB</td>
<td>4.06 MB</td>
<td>40.34 MB</td>
<td>403.15 MB</td>
</tr>
</tbody>
</table>
<p>嵌入的数据越大程序也就越大。</p>
<h2 id="一些坑点">一些坑点</h2>
<p>我们已经学习了embed指令的语法以及使用方法，在收尾前还有一些注意事项需要知道：</p>
<ol>
<li>embed会拖慢编译时间并占用大量内存，拿上一节的程序测试4GB大小的嵌入数据，在16g Linux笔记本上OOM。</li>
<li>embed不限制嵌入资源的大小，比如/dev/urandom这种没有大小限制的文件会导致资源耗尽。</li>
<li>文本编码问题，embed是把数据原样转换后写入程序的，因此它不知道你的文本是什么编码，理论上也不应该知道。</li>
<li>文本数据的换行符问题，Windows上换行符是<code>\r\n</code>，而macOS和Linux上是<code>\n</code>，标准库的io很多时候帮我们处理掉了两者之间的差异，但embed并不会，它之后原样照搬数据，如果不注意这个问题可能会导致长度计算错误或者数据处理逻辑上出现缺陷。</li>
<li>字节序问题，到目前为止还没有字节序问题出现，因为我们做测试的几个平台<code>CHAR_BIT</code>都是8，也就是八位一字节，在embed里就是8位转成一个整数，这是没有字节序问题的。然而一个<code>CHAR_BIT</code>大于8的平台，就可能会遇到16位甚至32位二进制数据转成一个整数的情况，这时候就会出现字节序问题。标准没有规定编译器用哪种字节序处理嵌入数据，只是建议采用和程序运行时一致的字节序来处理。这导致了理论上<code>#embed</code>的可移植性会比较弱。不过实际上现在大部分服务器和桌面环境里<code>CHAR_BIT</code>都是8，因此遇到问题的机会不多，但得了解到存在这种坑。</li>
<li>编译错误可能很难理解，<code>#embed</code>是预处理器指令，预处理器处理完源代码还需要编译器进行编译，有时候预处理器能正确处理完成的数据在编译器那里不一定是合法的代码，这时候编译器在报错的东西是完成替换后的内容了，不是第一现场导致报错内容的有效信息不多。由于embed还支持大部分的宏扩展替换，导致代码进一步变形，最终有可能会找不到错误的源头所在（比如某个宏展开有问题导致生成的代码不能编译），你可以在介绍prefix的例子里删掉一个逗号体验一下。</li>
</ol>
<p>不过目前只有少数编译器支持<code>#embed</code>特性，等支持更广泛之后其中一些坑可能会在后续的标准规范里修复或者交给编译器自己定夺。</p>
<h2 id="总结">总结</h2>
<p>embed算是一个比较实用的功能，不过要等生态铺开可能还得好几年。</p>
<p>同样都是语言层面对内嵌数据的支持，c/c++相比golang的嵌入资源缺少了一些灵活性，但这也无可厚非。</p>
<p>总而言之，在看完这篇指南之后可以尝试使用一下<code>#embed</code>，说不定可以从项目中删掉一两个外部工具减轻负担。</p>
<h5 id="参考">参考</h5>
<p>embed提案 p1967</p><br><br>
来源：https://www.cnblogs.com/apocelipes/p/18983462

查看完整版本: C23和C++26的#embed嵌入资源指南