简介：BCH编译码的C语言实现包，专注于纠错编码技术，适合通信、存储及数据传输场景下的算法研究者、嵌入式工程师及相关课程学习者。压缩包内仅1个C源文件，体积约5KB，函数结构集中，便于快速阅读、修改和移植到实际项目中。资源发布后已有1423人学习下载，是入门BCH码的实用参考资料。实现代码从伽罗华域GF(2^n)多项式运算出发，覆盖生成多项式构造、编码转换以及BM迭代译码等关键环节；通过代码可直观理解错误定位与校正流程，并结合注释把握软决策与硬决策的差异，以及位操作、查表等性能优化思路。该源码还展示了离散数学与编码理论在C语言中的落地方式，适合搭配教材逐步调试运行，夯实纠错编码功底。
1. BCH 编译码的 C 语言实现：从 GF(2^m) 到可落地的纠错代码
很多人一听到 BCH 码就头大，觉得那是通信专业课里才碰得到的东西，离实际工程很远。但真正在嵌入式存储、NAND Flash 控制、无线数传模块里摸过纠错的人会告诉你：BCH 码是少数能用纯 C 在单片机上跑起来的强力纠错方案，没有专利授权问题，实现得好的话，几百行代码就能搞定编码和译码。这次拆的资源就是一个完整的 BCH 编译码 C 语言实现，覆盖伽罗华域运算、生成多项式构造、编码器、伴随式计算、BM 迭代译码和钱搜索整个链路。适合三类人：一是要在 MCU 或 FPGA 软核里做 ECC 的嵌入式工程师，二是写存储驱动需要校验算法的系统程序员，三是想搞懂 BCH 原理但不想啃数学推导的学生。这份资源最大的价值不是给你一个库文件，而是把每个模块的 C 代码和原理对应起来，让你改得动参数、查得了错。
2. 伽罗华域 GF(2^m) 的 C 实现：BCH 码的数学地基
2.1 为什么要自己建域，而不是直接算多项式
BCH 码的所有运算都发生在有限域 GF(2^m) 里，这个域里有 2^m 个元素，加减法等价于异或，乘法是多项式乘法再对某个本原多项式取模。教材上写得很抽象，但落到 C 代码里就两件事：建表、查表。你不需要真的在代码里做多项式乘法，因为那太慢了。常见做法是预先算好指数表和对数表，把乘法变成查表加查表再加查表。
指数表是这样来的：选定一个本原多项式，比如 GF(2^4) 常用 0x13（即 x^4 + x + 1），然后从 1 开始反复乘 α，把每一步的结果记录成表。对数表则是反过来，从元素值查到指数。有了这两张表，域内乘法就是查对数表、相加、再查指数表，三步完成。注意如果相加结果大于等于 2^m - 1，要模掉，因为域的非零元素构成循环群。
// GF(2^m) 建表核心代码 #define GF_M 4 // 域维度 #define GF_POLY 0x13 // 本原多项式 x^4 + x + 1 #define GF_SIZE (1 << GF_M) // 16 #define GF_N (GF_SIZE - 1) // 15，非零元素个数 static uint8_t gf_exp[GF_SIZE * 2]; static uint8_t gf_log[GF_SIZE]; void gf_init(void) { int i, x = 1; for (i = 0; i < GF_N; i++) { gf_exp[i] = x; gf_log[x] = i; x <<= 1; if (x & GF_SIZE) // 溢出位说明已经到了 x^m 项 x ^= GF_POLY; // 对本原多项式取模 } for (i = GF_N; i < GF_SIZE * 2; i++) gf_exp[i] = gf_exp[i - GF_N]; // 扩展一倍，免去取模 } uint8_t gf_mul(uint8_t a, uint8_t b) { if (a == 0 || b == 0) return 0; return gf_exp[gf_log[a] + gf_log[b]]; }这段代码里最关键的是建表那段：x <<= 1其实就是多项式乘以 α，如果左移溢出了GF_SIZE位，说明出现了 x^m 项，这时候异或上本原多项式，等价于做模运算。扩展一倍指数的做法是工程上常用的小优化，这样在译码阶段频繁做乘法时，不用每次都对指数和取模，省掉一个条件判断。代价是内存多花GF_SIZE个字节，对嵌入式平台完全值得。
2.2 域参数怎么选：BCH(15, 7, 5) 到 BCH(255, 239, 8) 的扩展路径
资源的代码把域参数做成了宏定义，这就是整个资源最方便的地方。你不需要改函数逻辑，只要改GF_M和GF_POLY两个宏，就能在 GF(2^4)、GF(2^5)、GF(2^8) 之间切换。但要提醒你，这不是无脑改两个数字就行。GF_POLY必须是本原多项式，每个 m 值都有标准的本原多项式列表，网上很容易查到。比如 GF(2^8) 常用 0x11D（x^8 + x^4 + x^3 + x^2 + 1），这也是 AES 加密里用的那个，但 AES 的域和 BCH 的域只要本原多项式一致就能复用同套表。
另一个坑是码长和域大小的关系。BCH 码的码长 n 必须是 2^m - 1 的因子或是它本身。你用 GF(2^8) 建域，最多只能构造 n=255 的码，想搞 n=128 的缩短码，得从 255 的码里截断。资源的代码默认支持满码长，缩短码需要你自己在编码前把信息位左移对齐，这个后面编码那章会细说。
我一般建议第一次跑通用 BCH(15, 7, 5)：码长 15，信息位 7，纠错能力 t=2。因为数小，你能手工验证每一组输出，比如编码后的码字、伴随式的值、错误位置多项式系数，这些都能对照教材习题。等完全跑通了再切到 255 的码长。
3. 编码器实现：生成多项式和多项式除法
3.1 生成多项式怎么来：最小多项式与 lcm 的代码落地
BCH 码的生成多项式 g(x) 是若干最小多项式的最小公倍式。理论说完了，代码怎么搞？最简单的办法是预先算好并存成常量表。资源里给了 t 从 1 到 8 的生成多项式系数表，你直接抄就行。但如果你要改参数，就得自己算。这里有个省事的思路：既然你已经有 gf_exp 和 gf_log 表了，求最小多项式其实就是在 GF(2^m) 里做因子分解。
具体算法不复杂：对每个 α^i（i 从 1 到 2t），找它的共轭类 {α^i, α^(2i), α^(4i), ...}，每个共轭类对应一个最小多项式。最小多项式的系数可以通过遍历所有可能的组合来解。但资源里没搞那么复杂，而是提供了一段辅助代码，用穷举法验证你输入的生成多项式是否满足g(α^i) = 0对 i=1..2t 都成立：
// 验证生成多项式是否正确 int gx_verify(const uint8_t *gx, int deg_gx, int t) { int i, j, val; for (i = 1; i <= 2 * t; i++) { val = 0; // 霍纳法求 g(α^i) for (j = deg_gx; j >= 0; j--) { if (j == deg_gx) { val = gx[j]; // 最高次系数恒为 1 } else { val = gf_mul(val, gf_exp[i]); val ^= gx[j]; } } if (val != 0) return 0; // g(α^i) 必须为 0 } return 1; }验证的原理很直接：如果生成的 g(x) 是对的，那么对任意 i ∈ [1, 2t]，g(α^i) 必须等于 0。这个验证函数在你自己手工计算生成多项式的时候非常有用。很多教程直接给出多项式让你用，但没说怎么验算。资源的做法是给出常见参数对应的系数表，同时留了这个 verify 函数，让你在改了参数之后能自查。
3.2 系统码编码：线性反馈移位寄存器还是查表法
BCH 编码的本质是：信息多项式 m(x) 乘以 x^(n-k)，再除以生成多项式 g(x)，余数就是校验位。C 语言实现有两种主流方案：查表法和 LFSR 模拟法。资源里用的是 LFSR 法，因为它内存占用极小，适合单片机场景。
// BCH 系统码编码，输入 info 数组，输出 codeword 数组 void bch_encode(const uint8_t *info, uint8_t *codeword, int k, int n, const uint8_t *gx, int deg_gx) { int i, j; uint8_t reg[GF_M * 2] = {0}; // 余数寄存器数组 // 1. 信息位直接复制到码字前段 for (i = 0; i < k; i++) codeword[i] = info[i]; // 2. 后段补零 for (i = k; i < n; i++) codeword[i] = 0; // 3. 用 LFSR 算余数 for (i = 0; i < k; i++) { uint8_t fb = reg[deg_gx - 1] ^ info[i]; // 反馈移位 for (j = deg_gx - 1; j > 0; j--) reg[j] = reg[j - 1] ^ (fb ? gx[j] : 0); reg[0] = fb ? gx[0] : 0; } // 4. 余数写入码字尾部 for (i = 0; i < deg_gx; i++) codeword[k + i] = reg[i]; }这个 LFSR 编码的代码是资源里最值得背下来的一段，但有两个容易迷糊的点。第一，reg数组长度为什么是deg_gx而不是别的——因为余数的次数最高比 g(x) 低一次，所以 deg_gx 个寄存器就够。第二，fb = reg[deg_gx-1] ^ info[i]这一步是逐比特处理的，和硬件的 LFSR 行为一致。如果你在软件里跑，逐比特会慢，但好在 BCH 的信息位通常不超过几百比特，MCU 主频足够。
要注意的是这段代码默认码字是不打乱顺序的「信息位在前、校验位在后」结构，也就是系统码。BCH 作为循环码天然是系统码形式，这对调试很友好，收到码字直接前 k 个比特就是原始数据。如果你看到某个实现输出的码字顺序是反的，那它可能做了非系统编码，接收端解码后还要逆变换，没必要。
4. 译码器实现：伴随式计算、BM 迭代与钱搜索
4.1 伴随式计算的代码逻辑：为什么是 S_i = r(α^i)
译码是整个 BCH 实现里最难的部分，也是资源里代码量最大的部分。第一步是伴随式计算，本质就是把接收到的码字当成多项式 r(x)，然后求 r(α^i)，i=1..2t。因为生成多项式 g(x) 的根就是 α^1 到 α^(2t)，所以如果传输没出错，所有伴随式应该都是 0。伴随式非零就说明有错误，且 S_i 的值包含了错误位置和错误值的信息。
// 计算伴随式 void bch_syndrome(const uint8_t *rx, int n, int t, uint8_t *syndrome) { int i, j; for (i = 0; i < 2 * t; i++) { uint8_t val = 0; // 霍纳法：从最高次到最低次迭代 for (j = n - 1; j >= 0; j--) { val = gf_mul(val, gf_exp[i + 1]); // 注意 i+1：α^(i+1) val ^= rx[j]; } syndrome[i] = val; } }这段代码有效但有个细节值得注意：循环里用的是gf_exp[i + 1]而不是gf_exp[i]，因为伴随式定义是 S_1 = r(α^1)，S_2 = r(α^2)，C 数组下标从 0 开始，所以下标 i 对应 α^(i+1)。另外这里用霍纳法迭代，每个伴随式的计算复杂度是 O(n)，2t 个伴随式就是 O(nt)。对 n=255 的码来说，2t=16，大约 4080 次域乘，在 MCU 上是微秒级的开销。真要考虑性能，可以做伴随式的 FFT 加速，但一般没这个必要。
4.2 BM 迭代译码：关键方程与 C 代码的对应关系
伴随式算完，下一步是求错误位置多项式 σ(x)。最有名的两个方法是 Peterson 解线性方程组和 BM 迭代。Peterson 在 t=2 的时候很好用，直接套公式，但 t 变大后矩阵规模跟着变大，代码写起来很笨重。资源用的是 BM 算法，迭代次数等于 2t，每次迭代做一次多项式更新。这个算法对熟手来说不算复杂，但对新手来说，代码和数学公式之间总隔一层纱。
// BM 迭代求错误位置多项式 void bm_algorithm(const uint8_t *s, int t, uint8_t *sigma, int *sigma_deg) { uint8_t C[GF_M * 2] = {0}; // 当前多项式 uint8_t B[GF_M * 2] = {0}; // 上一次更新的多项式 int L = 0, m = 1; uint8_t b = 1; int i, n; C[0] = 1; B[0] = 1; for (n = 0; n < 2 * t; n++) { // 计算差值 delta uint8_t delta = s[n]; for (i = 1; i <= L; i++) delta ^= gf_mul(C[i], s[n - i]); if (delta == 0) { m++; } else if (2 * L <= n) { // 更新 C 和 B uint8_t T[GF_M * 2]; memcpy(T, C, sizeof(T)); uint8_t coef = gf_div(delta, b); // 需要额外实现 gf_div for (i = 0; i <= GF_M * 2 - 1; i++) C[i + m] ^= gf_mul(coef, B[i]); L = n + 1 - L; memcpy(B, T, sizeof(T)); b = delta; m = 1; } else { m++; } } memcpy(sigma, C, (L + 1) * sizeof(uint8_t)); *sigma_deg = L; }这段代码里最容易踩坑的是delta的计算。公式看起来简单：delta = S_n + C_1·S_{n-1} + C_2·S_{n-2} + ...，但实现时你要注意 C_i 的下标是对应的幂次，不是数组下标。C 数组的 C[i] 表示 σ(x) 的第 i 次项系数，所以 delta 算的是第 n 个「不一致值」。另外gf_div是域内除法，需要自己实现，用对数表做就是两个对数相减再查指数表，很便宜。
BM 算法有两个分支条件，2*L <= n时更新多项式的阶数，否则只做 m 计数。这个 m 变量代表当前迭代和上一次更新的间隔，很多人在这里写错导致译码失败。我建议多打印中间过程对照教材的数值例子来调试，比如用 BCH(15,7,5) 造一个 2 比特错误，手动跟踪每一步的 delta、C、B、L 的值。
4.3 钱搜索找错误位置：穷举 α 的幂次
错误位置多项式求出来之后，错误位置就是 σ(x) 的根。但注意这里有个反直觉的地方：如果错误位置是 X_i，那么 σ(x) 的根是 X_i 的倒数，也就是 X_i^{-1}。所以要么你求 σ(x) 的根再取倒数，要么直接把 x = α^j 代入 σ(x) 算出来为 0 时，说明 α^j 是根，错误位置就是 α^{-j}。钱搜索用的是后面这个思路。
钱搜索的实现非常粗暴但高效：对 j = 0 到 n-1，算 σ(α^j) 是否为 0。但 σ(α^j) 里面有 j 次方的项，每次都要重新计算的话复杂度是 O(n·t)。资源的代码做了一个典型优化：把 σ(x) 拆成奇次项和偶次项，然后利用 σ(α^j) 的递推关系，每次迭代只做常数次乘法和加法。
// 钱搜索核心代码：找出所有错误位置 int chien_search(const uint8_t *sigma, int sigma_deg, int n, uint8_t *err_pos) { int i, j, cnt = 0; uint8_t s[GF_M * 2], pow[GF_M * 2]; // 初始化：s[i] = σ_i，pow[i] = α^i for (i = 0; i <= sigma_deg; i++) { s[i] = sigma[i]; pow[i] = gf_exp[i]; } for (j = 1; j <= n; j++) { uint8_t sum = 0; for (i = 0; i <= sigma_deg; i++) { sum ^= s[i]; s[i] = gf_mul(s[i], pow[i]); // 每个 σ_i 乘以 α^i } if (sum == 0) { err_pos[cnt++] = n - j; // 位置码字是从低位到高位排的 } } return cnt; }这段代码的妙处在s[i] = gf_mul(s[i], pow[i])这一步：每一轮 j 循环后，s[i] 从 σ_i 变成 σ_i·α^i，再从 σ_i·α^i 变成 σ_i·α^(2i)，相当于自动完成了 σ(α^j) 中 α^(j·i) 的递增，省掉了反复幂运算。这是钱搜索标准实现里的经典优化。错误位置映射err_pos[cnt++] = n - j也要理解：循环里 j 从 1 到 n，对应的是 α^j，而 α^j = X^{-1}，所以实际错误位置 X = α^{-j} = α^(n-j)，在码字数组里就是第 n-j 个位置（从 0 开始算）。
4.4 错误值的计算与纠错：Forney 算法的实际应用
找到错误位置还不够，你还得知道每个位置错了多少。因为 BCH 是二进制码，每个位置只有 0 和 1 两种可能，所以错误值就是翻转比特。这也是二进制 BCH 比 RS 码简单的原因——不需要算错误值多项式，找到位置直接翻转即可。但资源里的实现还是保留了 Forney 算法的骨架，以便将来扩展成非二进制 BCH 或 RS 码。
// 纠错主流程 int bch_correct(uint8_t *rx, int n, int t, int k) { uint8_t syndrome[GF_M * 2]; uint8_t sigma[GF_M * 2]; int sigma_deg = 0; uint8_t err_pos[GF_M * 2]; int i, err_cnt; // 1. 计算伴随式 bch_syndrome(rx, n, t, syndrome); // 2. 伴随式全零则无错误 int all_zero = 1; for (i = 0; i < 2 * t; i++) { if (syndrome[i] != 0) { all_zero = 0; break; } } if (all_zero) return 0; // 3. BM 迭代 bm_algorithm(syndrome, t, sigma, &sigma_deg); // 4. 钱搜索 err_cnt = chien_search(sigma, sigma_deg, n, err_pos); if (err_cnt == 0 || err_cnt > t) return -1; // 超出纠错能力 // 5. 翻转错误位置的比特 for (i = 0; i < err_cnt; i++) { if (err_pos[i] < n) { rx[err_pos[i]] ^= 1; // 二进制 BCH：翻转即可 } } return err_cnt; }纠错主流程就是「伴随式 → 判断全零 → BM → 钱搜索 → 翻转」五步。注意err_cnt > t的边界检查，这个必须在钱搜索之后做：如果找出来的错误位置数量超过 t，说明错误太严重，超出了码的纠错能力，强行纠错只会越纠越错。返回 -1 让上层自己决定是重传还是报错。
5. BCH 编译码避坑指南：从参数配置到野指针的 5 个实战教训
5.1 坑一：GF(2^m) 建表时本原多项式选错，编码结果全对但译码伴随式全零
现象：编码端输出的码字看起来是正常的，信息位和校验位都填得整整齐齐，但接收端算伴随式时全部为 0，好像传输过程中一个错都没有。可明明你人工注入了一个比特错误。
原因：编码端和解码端用了不同的本原多项式建表。比如发送端 GF_POLY = 0x13，接收端 GF_POLY = 0x1F，两边跑的是不同的域结构。编码是按发送端的域编码的，解码按接收端的域算伴随式，自然算不出有效结果。
解决：把GF_POLY定义成全局唯一的宏，不要在每个文件里重复定义。更好的办法是编译时用#ifndef保护，在头文件里统一声明。我自己的习惯是：这套代码固定放在一个gf.c/gf.h文件里，所有模块 include 同一个头文件，改参数只改一处，然后跑一遍自检函数gx_verify。
5.2 坑二：BM 迭代里 gf_div 被除数为 0，程序直接崩掉
现象：运行到coef = gf_div(delta, b)时，程序进入异常或者输出 NaN。用调试器看，b变量为 0。
原因：BM 算法里，b存的是上一次 delta 不为零时的值，理论算法里保证它非零。但如果你误把b初始化为 0，或者更新逻辑写错导致 b 被清零，就会除零。另外，有些实现里gf_div没做 0 值保护。
解决：先看代码逻辑，b初始化为 1 是对的——因为第一次迭代之前，delta 至少有一个非零值，用 1 作为初始分母合理。其次，gf_div里加个保护：if (b == 0) return 0;或者在调用前断言。实际工程项目里，这个保护能让你把精力集中在真正的算法 bug 上，而不是被一个除零打断。
5.3 坑三：钱搜索返回的错误位置超出码长边界
现象：纠错时err_pos[i]出现大于等于 n 的值，然后你去访问rx[err_pos[i]]直接越界写坏内存。
原因：钱搜索循环范围写错了。标准实现循环 j 从 1 到 n，对应 α^1 到 α^n，但有些改动版本把范围写成了 0 到 n-1，导致 α^0 = 1 被第一个算进去，那个位置上如果 sum 为 0，算出来的位置映射不对。
解决：在纠错主流程里加越界判断，就是前面代码里的if (err_pos[i] < n)。但这只是治标。治本是把钱搜索的循环边界和位置映射公式对照清楚。我的经验是：先用 t=1 的 BCH(15, 11, 3) 做单错测试，错误位置已知，盯着钱搜索的输出看是否符合预期，跑通了再上高 t 值。
5.4 坑四：缩短码没有对齐，前导零被当成信息位
现象：用 BCH(255, 239, 8) 缩短成 (128, 112, 8) 来用，编码时直接往编码函数里塞 112 比特信息，结果接收端怎么纠都错。
原因：缩短码的正确做法是：把码长从 255 缩到 128，信息位从 239 缩到 112，相当于在高位补了 127 个 0 的虚拟信息位。编码的时候必须先把这 127 个 0 放进码字的高位，再对真实的 112 比特做编码，最后只发送 128 比特。如果你直接把 112 比特当 k 传给编码器，生成多项式的次数对应的校验位长度不变（还是 16 比特），但位序完全错位。
解决：写一个缩短码适配层。编码前把信息数组映射到高位，低位置 0，编码完成后只截取从第 127 位开始的 128 个比特。解码时同理，在接收数组前面补 127 个 0 再送进译码器。这个逻辑说起来简单，但代码里很容易漏掉补零操作。
5.5 坑五：平台字节序导致码字数组位序错乱
现象：同一段代码在 x86 上跑没问题，交叉编译到 ARM 板子上，编码结果完全不同。
原因：如果你把码字按 16 比特或 32 比特整型存储，大端小端转换会改变比特的物理顺序。BCH 码的所有多项式运算都是按位进行的，位序一旦乱了，整个代数结构就塌了。
解决：统一用uint8_t数组逐比特存储码字，每个数组元素存一个比特（0 或 1），不用位域结构体。虽然内存多花一点，但换取的是平台无关性。如果你非要压缩存储，用比特数组，那么所有读写操作必须走统一的 GET_BIT/SET_BIT 宏，绝不在业务代码里直接操作位域。
6. 进阶验证方法：用模拟信道测出你实现的实际纠错能力
代码写完不代表完了，你得证明它真的能纠错。我调试 BCH 实现的标准做法是写一个模拟信道：生成随机信息位，编码，按一定比例随机翻转比特，译码，最后比对译码输出和原始信息。这个流程能同时验证编码端、译码端、边界条件处理三个环节。
验证脚本本身不复杂，但要覆盖三个层次。第一层是 0 错误场景，这时伴随式全零，译码函数应该原样返回。第二层是小于等于 t 个错误，这是码的设计纠错能力，必须全部纠正回来。第三层是超过 t 个错误的场景，这时候允许译码失败，但不允许出现错误纠正成功但结果仍然出错的情况——也就是说，超界错误必须被err_cnt > t的检查拦下来。
// 模拟信道测试框架 void test_bch_channel(int n, int k, int t, int test_count) { int i, j, pass = 0; for (i = 0; i < test_count; i++) { uint8_t info[GF_M * 2], tx[GF_M * 2], rx[GF_M * 2]; // 1. 随机生成信息位 for (j = 0; j < k; j++) info[j] = rand() & 1; // 2. 编码 bch_encode(info, tx, k, n, gx_table[t], gx_deg[t]); // 3. 注入随机错误 memcpy(rx, tx, n); int errs = rand() % (t + 1); // 控制在 t 以内 for (j = 0; j < errs; j++) { int pos = rand() % n; rx[pos] ^= 1; } // 4. 译码 int ret = bch_correct(rx, n, t, k); // 5. 验证 if (ret >= 0 && memcmp(rx, tx, n) == 0) pass++; else if (ret < 0) printf("decode fail at test %d\n", i); else printf("wrong decode at test %d\n", i); } printf("pass rate: %d/%d\n", pass, test_count); }这个测试框架里最关键的是第 3 步——注入的错误数量要控制在 t 以内。如果你想测超界行为，把rand() % (t + 1)改成rand() % n，会注入更多错误，然后观察解码失败的判据是否触发。注意这里有个细节：memcmp(rx, tx, n)比较的是解码后的码字和原始发送码字，而不是信息位。因为如果解码正确，整个码字包括校验位都应该和发送时一致。只比信息位会漏掉校验位的错误。
跑通这个测试之后，你还可以加一个误码率统计：固定错误注入概率 p，跑上万次测试，统计「解码失败率」和「误纠率」。误纠率是最危险的指标——它表示译码器把错误的码字当成了正确的，还成功翻转了一些比特，结果数据更烂了。优秀的 BCH 实现必须做到误纠率接近于零。
我那会儿调试一个 GF(2^8) 的 BCH(255, 239, 8) 实现，卡了整整两天，最后发现是钱搜索的循环边界多了 1，导致位置映射错了一位。从那以后我每次写完译码器都强制跑一遍这个模拟信道测试，而且在注入错误时故意把错误的比特位置写在打印日志里，一旦翻车能直接对照。希望这份资源的坑和验证方法能帮你少走几天弯路。
本文还有配套的精品资源，点击获取
