简介：面向Go语言零基础学习者与备考计算机二级C语言的读者，这份资料包将完整的Go语言进阶路径与C语言考试资料整合在一起。包内包含471个文件，压缩包大小约90.44MB，以308个Go源码文件、54张PNG示意图、28份Markdown笔记和26个GoHTML模板为主要构成；Go源码用于展示可运行案例，Markdown梳理知识点，示意图辅助理解流程，GoHTML演示模板渲染与数据绑定。内容覆盖变量、切片、管道、嵌套模板、数据格式化、性能剖析等主题，并用大量实例逐一拆解常见语法用法，适合从入门到进阶逐步查阅。目录按教程章节和主题模块分门别类，既方便系统学习，也便于快速定位专项内容。目前已有115人浏览学习，是一份兼顾Go语言系统训练与二级C语言备考查缺补漏的实用资料。

1. 计算机二级C语言：先看懂这张考试地图再动手

搜"计算机二级C语言资料"的人，多数第一反应是抱着语法书从头啃，结果读到指针又开始怀疑人生。这张考试其实可以画成一张很明确的地图：满分 100 分拆成选择题 40 分（里面夹着约 10 分公共基础知识）和操作题 60 分（程序填空、程序改错、程序设计，难度递进）。也就是说，决定过不过的关键不只是"会不会背语法"，而是"拿到一段陌生代码能不能快速读懂、在断点处补对、按题意写出完整函数"。这套笔记适合三类人：在校想顺手过级的、裸考没过准备二刷的、参加工作后需要补证书同时把 C 捡起来的。下面前两章先把语法地基抠细，第三、四章处理数组、指针、结构体、链表和文件这些大题大户，然后专门列一份易错清单，最后一章给出可以照着做的考前冲刺安排。

2. 语法地基：数据类型、运算符与流程控制中的高频考点

选择题前 10 来道题基本都在考语法细节。很多人栽在这里不是不会，而是被"一眼看过去很眼熟"的表达式骗了。这部分的复习策略应该反过来：先把最容易出陷阱的几类表达式收集齐，再回去看概念。

2.1 数据类型与表达式：先绕开 sizeof 和类型转换的坑

考纲里的基本类型有 char、short、int、long、float、double 和 unsigned 修饰。标准环境下，char 占 1 字节，short 占 2 字节，int 占 4 字节，float 占 4 字节，double 占 8 字节。long 在不同编译环境里可能是 4 字节或 8 字节，所以考试选择题如果问"long 占几个字节"，答案要按考纲指定环境来选；复习时建议自己写一段程序，在考点环境下把每个类型的 sizeof 打出来，形成肌肉记忆。最容易漏的一点：sizeof 是运算符不是函数，sizeof(int) 和 sizeof int 都合法，但选择题常把"函数"作为干扰项。

类型转换是另一个稳定送分点。自动转换按"低精度向高精度"的方向走：char/short 先转 int，float 运算时转 double，混和运算时按占字节多的和精度高的来。强制转换只对当前表达式的值生效，变量本身的类型不会变。做题时最容易翻车的写法是：

int a = 7; int b = 2; double r = (double)(a / b); // 注意：a/b 先按整数除得 3，再转 double 得 3.0

要想得到 3.5，正确的写法是(double)a / b。选择题考这种题时，很多人一看外面有 double 就选 3.5，实际答案是 3.0。这就是先算谁的问题。复习看表达式时，第一件事圈出"除法的两边是不是同类型"，再看外面套了什么。

运算符部分，优先级和结合性是二次考点里最值得背的一张表。只需要记住一句话的优先级顺序：单目 > 算术 > 关系 > 逻辑与 > 逻辑或 > 三目 > 赋值 > 逗号。按这个顺序看，i = a > b && c < d是先比较、再逻辑与、最后赋值。逗号表达式整个表达式的值等于最后一项的值，int x = (1, 2, 3);里 x 是 3。自增自减要分清先用后加和先加后用，考试常混在函数参数里考，比如printf("%d %d", i, i++);，这类题不用纠结编译器行为，按考纲答案来，刷题时见到就记一个结论。

位运算容易被当作冷门，其实选择题里隔三差五出现。右移一位相当于整除 2，左移一位相当于乘 2，按位异或可以用来交换两个数，这些结论要能反应出来。& 还可以用来判断奇偶：x & 1为 1 表示 x 是奇数。整段复习下来，建议把每类运算符配一个选择题原题记录在笔记上，不要只看概念。

2.2 选择结构与循环结构：条件边界决定满分还是送分

流程控制的选择题不难，难在两种固定陷阱。第一种是 else 的就近配对：if...if...else结构里，else 总是和最近的、还没有配对的 if 配对，缩进只是为了好看，不决定逻辑。复习时遇到嵌套选择题，先划出每个 else 的实际归属，再把代码改写成带大括号的等价形式，错误率能降一半。第二种是 switch 的穿透行为：每个 case 后面如果没有 break，会继续执行下一个 case 的语句，直到遇到 break 或 switch 结束。选择题常给一个没有 break 的 switch，问输出几个数，答案是"全部命中后的连续输出"，不是只进一个分支。

循环的考点要分三块。for 循环的执行顺序是"初始化一次、判断、循环体、增量、再判断"，判断为假才退出，所以for(i=0;i<=n;i++)实际循环 n+1 次，写边界时容易差一。while 和 do-while 的本质区别是 do-while 至少执行一次，选择题里"先执行后判断"的选项就是它。break 与 continue 的区别：break 跳出整个循环，continue 跳过本轮剩余语句进入下一轮，遇到嵌套循环时 break 只跳出一层。复习的时候把三种循环互相改写练一遍，比如把 for 改成 while，再看 while 条件里的自增位置，这是填空题常考的形态。

一个值得多花时间的细节是循环里的"累加器和标志位"。填空题经常给出空白的累加语句，比如求 1 到 100 的和、统计数字位数、判断素数。做这类题时先把循环体里已有的变量列出来，看看哪些被赋值但没用上，哪些被用但没初始化——填空答案往往就藏在变量清单里。这比硬读代码更快。

2.3 函数机制：参数传递方式与递归的展开过程

函数部分首先要分清传值和传址。C 语言里参数一律按值传递，传数组名或指针时，"值"是地址，所以能在函数里改到外部变量。选择题最爱问"下列哪个调用方式能改变实参的值"，答案是传指针、传数组名、传结构体指针。传结构体本身仍然是值传递，函数里改结构体副本不影响原结构体——这个点很多人漏，因为潜意识觉得"结构体很大应该传引用"。

形参和实参的区别也要能默写：形参只在函数被调用时分配内存，调用结束就释放；实参必须有确定的值。数组做函数参数时会退化成指针，所以函数内sizeof(a)得到的是指针大小，不是数组大小。这个细节和前面 sizeof 内容连在一起，是选择题和改错题的共同高频点。

递归要看的不是代码，是"展开过程"。一个正确的递归必须有两个要素：递归出口和递归调用。写递归调用的填空题时，先把递归公式列出来，比如斐波那契f(n) = f(n-1) + f(n-2)，再看题里的返回语句缺了什么参数。最容易错的是递归里变量作用域和每次调用的独立栈帧，比如全局变量在递归里会被反复修改，局部变量每次调用都重新初始化。static局部变量是另一个重点：它只初始化一次，函数被多次调用时值会保留上一次的结果。选择题里出现static int i = 0;的计数器，答案往往比非 static 版本大，因为不会被每次调用重置。

3. 数组、指针与字符串：占分最稳的三块硬骨头

到了这一章，基本就进入考试的腹地了。程序填空和改错题的大头都集中在这三块上。复习的难点在于它们彼此纠缠：指针离开数组就没意思，字符串本质上又是字符数组。建议把三者当一条线来学，不要分开背。

3.1 一维与二维数组：下标、初值与地址的对应关系

一维数组先锁死三个结论：数组名是首地址常量，a[i]等价于*(a+i)，下标从 0 开始。选择题和填空题经常在"下标越界"上设埋伏，比如定义int a[5]，题目却访问a[5]，这在语法上合法但越界，答案是"不确定的随机值"，不是报错。数组初始化也有结论：int a[5] = {1,2,3};剩余元素自动补 0；int a[] = {1,2,3};数组大小由初始化列表决定，是 3。

二维数组最容易出错的点是指针算术。int a[3][4]是一个含 3 行、每行 4 个 int 的数组，a的类型是"指向含 4 个 int 的一维数组的指针"。关键结论：

• a+i跳过的是 i 行，不是 i 个元素；
• *(a+i)得到第 i 行的首地址，类型是int *；
• *(*(a+i)+j)等价于a[i][j]；
• a[i]本身是一个地址，等价于*(a+i)。

改错题里经常看见有人写*(a+i+j)想访问第 i 行第 j 列，这是错的，正确写法是*(*(a+i)+j)。选择题还爱考数组名做函数参数时的退化问题：void f(int a[][4])中，第二个维度必须写明，因为编译器要按 4 个 int 算出每一行的地址步长；第一个维度可以省略。

刷题时建议把所有"地址等价关系"整理成一张表，比如a、&a[0]、&a[0][0]的值相同但类型不同，a+1与&a[1]相同但步长是整行。类型不同在赋值和传参时才显形，这是最容易忽略的层面。

3.2 指针与数组的纠缠：指针数组、数组指针与函数指针

指针模块的知识点密度很高，但一定先从"指针是什么"出发：指针是个变量，里面存的是地址。它本身也有类型，类型决定它参与运算时的步长。int *p; p+1向后移动一个 int 的大小（4 字节），p指向 int；void *p是通用指针，不能直接做算术运算。这个基础不牢，后面的形态一律记不住。

接下来要死磕两组名字非常像、含义完全不同的事物。第一组是指针数组和数组指针：

int *p[3]; // p 是数组，里面放了 3 个 int* 元素 int (*q)[4]; // q 是指针，指向一个含 4 个 int 的数组

读法规则很简单：先找变量名，然后从内往外读。p先和[3]结合，所以它是数组；q先和*结合，所以它是指针。选择题给这种声明问"哪个是指针数组/数组指针"时，只要看变量名右边先接[ ]还是先接*。注意(*q)[4]中 q 的步长是 4 个 int，二维数组名的类型就和它一致，所以int a[3][4]; q=a;合法。

第二组是普通函数指针和返回指针的函数。int (*fp)(int, int)是函数指针，存放函数入口地址；int *f(int, int)是函数返回 int 指针。函数指针常用于回调，选择题里出现fp = func;时，后面调用fp(2,3)和直接调func(2,3)等价。改错题里如果声明写着int *f();而函数体return的是 int 值，那就是类型不匹配。

还有三个容易混淆的指针形态：二级指针int **p指向 int 指针；空指针NULL表示哪里都不指向，野指针则是"指向了已释放或未分配的区域"。程序填空里常见的套路是：函数要修改调用者的指针变量本身，就必须传指针的地址，即int **pp，否则函数内p = malloc(...)只改了形参副本，外部指针依然为空。这个点不掌握，链表那章的程序设计题会写得很痛苦。

3.3 字符串处理：'\0' 带来的边界连锁反应

C 语言没有字符串类型，字符串是字符数组加上结尾的'\0'。这个'\0'是所有字符串题的总开关。

先看两个最常见的对比：

char s1[] = "hello"; // 数组大小自动定为 6，最后一个是 '\0' char *s2 = "hello"; // s2 指向只读字符串常量

s1可以修改内容，s2指向的常量不能改，改就会运行时出错。改错题经常出现char *s = "hello"; s[0] = 'H';，这就是典型的向只读区写入。另外，sizeof(s1)是 6（包含'\0'），strlen(s1)是 5；sizeof(s2)是指针大小（4 或 8），strlen(s2)还是 5。这个对比表建议背下来。

字符串库函数要掌握以下结论：

• strcmp按字典序比较，返回 0 表示相等，if(strcmp(a,b)==0)才是比较内容；
• strcpy(dest, src)不检查目标空间大小，目标数组必须足够大；
• strcat(dest, src)从 dest 的'\0'位置开始拼接，会覆盖掉原来的'\0'；
• strlen遇'\0'停止，里没有'\0'时会一直数到随机边界。

填空和改错里最常见的字符串错误是"忘写'\0'"。比如手动拷贝字符数组的循环结束后，没有在末尾加'\0'，导致后面字符串操作越界；又或者gets和fgets混用后残留换行符。

这里补一个实用的复习方法：把标准字符串函数自己用指针实现一遍，strlen可以写成while(*p) p++;，strcpy可以写成while((*dest++ = *src++));。这个练过之后，程序填空里的同类代码扫一眼就能读懂，因为出题人用的就是这些最基本的指针操作模式。

4. 结构体、链表、文件与公共基础：操作题后半场的综合套路

这一章对应的是操作题里较难的部分，也是选择题里"数据结构应用"题的来源。它的特点是知识点单个看都不难，难在一串连起来。结构体是容器，链表是结构体的动态组合，文件读写是程序和外部存储的桥梁，公共基础则是和 C 语法无关但固定占 10 分的小题库。

4.1 结构体与共用体：成员访问与 sizeof 计算规则

结构体定义本身不占内存，定义变量才分配空间。成员访问有两种：结构体变量用.，结构体指针用->，p->name等价于(*p).name。选择题里容易混的是"通过二级指针访问成员"和"结构体数组的元素访问"，做题时先确定左侧是变量还是指针，再选符号。

typedef起别名是结构体模块的常客，typedef struct Node{...} Node;之后可以直接写Node a;而不用每次带struct。链表的结点定义几乎都用这个写法，考试代码里如果见到了，要立刻反应过来它是一种类型别名，不是宏替换。

sizeof(struct ...)是选择题稳定考点，因为它考的是内存对齐规则，不是简单的成员相加。规则是：结构体每个成员的偏移量必须是该成员自身大小的整数倍；结构体总大小必须是所有成员中最大对齐数的整数倍。举例：

struct S { char a; int b; char c; };

char 占 1，int 占 4，按规则排布后，a 偏移为 0，b 的偏移要跳到 4，c 偏移为 8，成员总字节数是 9，总大小要对齐到 4 的倍数，所以sizeof(struct S)是 12。如果成员顺序是int b; char a; char c;，对齐后是 8 字节。这个结论很多人在第一次刷题时都漏了，以为答案 1+4+1=6。复习时把常见的几个组合手算一遍，再上机验证一次。

共用体union与结构体相反：所有成员共享同一段内存，大小等于最大成员的大小（同样要按对齐规则向上取整），同一时刻只有一个成员有意义。选择题常问union和struct的存储区别，答"共用体成员共存于同一块内存、修改一个会影响另一个"就对了。枚举类型enum也要知道，它默认从 0 开始递增，可以指定初值，指定后后面依次加 1。

4.2 链表操作：动态内存分配的完整闭环

链表题在程序填空和程序设计里出现频率很高。它的核心是三个动作的指针顺序。

第一个动作是创建结点：

struct Node { int data; struct Node *next; }; struct Node *p = (struct Node*)malloc(sizeof(struct Node));

malloc返回void*，要强制转换成结点指针类型；分配后要检查是否为 NULL，分配失败返回的是空指针。配套的free(p)只释放内存，指针本身不会自动置空，所以释放后最好把指针赋为 NULL，防止悬空。

第二个动作是插入结点。这里有一条铁律：先连新结点，再断旧链接。头插法写错了会把链表后半段弄丢：

// 在结点 q 之后插入新结点 p p->next = q->next; // 先：新结点先链住 q 的后继 q->next = p; // 后：再把 q 的 next 指向新结点

顺序反过来的话，第一步q->next = p就把 q 的后继丢了，p->next = q->next实际取到的是 p 自己，形成错误的自环。改错题里如果有这两行交换位置，直接判错。尾插法和头插法的选择也常考：头插法遍历链表得到的序列与输入顺序相反，尾插法则保持一致。

第三个动作是删除结点。删除必须借助前驱指针，因为单向链表只能向后走。删除 q 的后继 p 的写法是：

q->next = p->next; free(p);

很多人漏的是先把 p 释放了再改指针，那样p->next已经是不可访问的野地址。正确的顺序永远是"先改链，再释放"。遍历链表时则要看清楚是从头结点开始还是从第一个数据结点开始，统计链表的长度、查找某个值的套路都一样：设一个指针从头出发，循环内p = p->next;配合计数。跑飞最常见的原因是没有判空就访问p->data。

4.3 文件读写：从打开方式到 EOF 判断的完整链条

文件这部分，选择题考函数参数，填空题考读写配对，改错题考模式字符串。总体的链条是五步：定义FILE *fp指针、fopen打开、读写操作、fclose关闭、fopen后判断返回值是否为 NULL。

FILE *fp = fopen("data.txt", "wb"); if (fp == NULL) { // 这个判空经常被漏写 return 1; } fprintf(fp, "%d %s\n", num, name); fclose(fp);

打开模式要能分辨："r"读、"w"写（覆盖原文件）、"a"追加、"rb"/"wb"二进制。"w"和"a"在文件不存在时都会创建，但"w"会先清空已存在的文件，"a"保留内容。选择题里问"哪个模式不会清空已有内容"答案是"a"。

读写函数要按配对记：

• 格式化读写：fprintf/fscanf，适合带格式的文本，fscanf遇到空白字符停止，所以读整行文本不行；
• 二进制块读写：fwrite/fread，参数是"地址、单个元素字节数、元素个数、文件指针"，适合结构体数组整体读写；
• 字符读写：fgetc/fputc；
• 字符串读写：fgets/fputs，fgets(buf, size, fp)最多读 size-1 个字符，自动加'\0'，它比gets安全，这是安全常识也是考点。

EOF 的判断是最常见的误区。feof(fp)只有在试图读越过文件尾部之后才返回真，所以"循环内先 feof 判断再读取"的写法会多读一次，正确姿势是"先读取，再判断是否到达文件末尾"：

int ch; while ((ch = fgetc(fp)) != EOF) { putchar(ch); }

fseek因为配合rewind和ftell做随机访问，也是填空的一员。rewind(fp)把位置指针搬回开头，ftell返回当前位置相对开头的偏移量。这些函数的名字要能默写，因为程序填空只给空不给函数名提示。

4.4 公共基础知识：10 分选择题的固定出题套路

公共基础知识这部分和 C 语法无关，但占选择题 10 分，很多人在复习中后期把它丢掉了。它的范围很固定：数据结构和算法约 4 分，软件工程基础约 3 分，数据库设计基础约 3 分。不用系统学整门课，只需要把高频考点记成小卡片。

数据结构部分要背结论：栈是后进先出，队列是先进先出，循环队列的题目看队头和队尾位置算元素个数；二叉树的第 k 层最多有 2 的 k-1 次方个结点，深度为 m 的满二叉树总结点数为 2 的 m 次方减 1；二叉树的三种遍历中，前序、中序、后序指的是根的位置。排序的时间复杂度是必背表：二分查找是 log2n，冒泡、直接插入是 n 的平方，快速排序平均 nlog2n 但最坏退化到 n 的平方，堆排序稳定在 nlog2n。选择题常给一张表让选"平均时间复杂度为 nlogn 的排序"。

软件工程部分的核心是生命周期和测试方法。软件生命周期包括可行性研究、需求分析、总体设计、详细设计、编码、测试和维护，需求分析阶段的常用工具是数据流图和数据字典。测试里白盒测试考逻辑覆盖，黑盒测试考等价类划分和边界值分析，单元测试的依据是详细设计说明书。选择题问"哪个属于白盒测试方法"选逻辑覆盖，问"黑盒测试"选边界值分析。

数据库部分抓住 E-R 图和关系运算。E-R 图里矩形是实体、椭圆是属性、菱形是联系。关系代数的选择、投影、连接要分清：选择是选行，投影是选列，连接是横向合并两个表。范式是另一个常考点：第一范式要求字段不可再分，第二范式要求消除部分函数依赖，第三范式要求消除传递函数依赖。看到"数据冗余""更新异常"的选项，往范式方向想。这一块的复习强度不用太高，能保证做对 6 分以上就够用。

5. 易漏点与易错点：六个考场翻车陷阱的排查清单

这一章把最容易失分的点集中排出来。每条都按"漏在哪、为什么漏、怎么补"的结构记，复习到后期可以直接当安检清单用。

5.1 scanf 缓冲区残留导致的"吃字符"

漏在哪：scanf("%d", &n);之后紧接scanf("%c", &c);，第二个 scanf 往往直接读到换行符，读不到输入的内容。 为什么漏：输入整数后按回车，换行符留在输入缓冲区里，%c会把它当成有效字符读走。 怎么补：在%c前加一个空格，写成scanf(" %c", &c);跳过空白字符；或者用getchar()先吃掉换行。改错题里出现%c时优先检查前面有没有残留问题。

5.2 字符串比较误用 == 比较地址

漏在哪：判断s1 == s2（s1、s2 是字符数组）来比对内容，逻辑上想比较字符串内容，实际上比较的是数组首地址。 为什么漏：字符串是数组，数组名是地址，地址通常不相等，所以这个判断永远为假。 怎么补：内容比较一律用strcmp(s1, s2) == 0。刷题时看到两个字符数组之间用==，第一反应就应是改错题。

5.3 指针未分配空间就写入

漏在哪：声明char *p;后直接scanf("%s", p);或strcpy(p, "hello");。 为什么漏：p 只声明没有指向任何合法内存，写入时写入未知地址，运行时不报错但结果不可预测。 怎么补：先分配空间，p = (char*)malloc(100 * sizeof(char));或使用固定大小的字符数组char p[100];。程序设计题的判分对这类错误几乎是零容忍，写指针前先问自己一句"它指向哪"。

5.4 循环边界差一：<= 与 < 弄反

漏在哪：求 1 到 n 的和写成for(i=1; i<n; i++)，少加一个 n。 为什么漏：看到i<n下意识觉得"循环到 n"，实际是到 n-1。 怎么补：把边界条件还原成"一共执行几次"来判断。i<n执行 n-1 次，i<=n执行 n 次，i<n+1也执行 n 次。填空题给空时，先数循环体执行次数，再反推条件。

5.5 switch 漏写 break 造成穿透

漏在哪：每个 case 的语句后没有 break，程序会继续执行下一个 case 直到 break 或 switch 结束。 为什么漏：把 switch 当成了 if，以为匹配一个分支就会自动跳出。 怎么补：阅读代码时逐 case 检查 break。程序填空题如果空位出现在 case 末尾，答案大概率就是break;。这也提醒复习时要把"每个 case 是否需要 break"养成一眼扫过去的习惯。

5.6 结构体大小没算内存对齐

漏在哪：算sizeof(struct)时直接把成员大小相加。 为什么漏：没意识到编译器会在成员之间和结构体尾部插入填充字节。 怎么补：按"成员偏移量对齐 + 总大小对齐到最大成员"两步算。遇到含char和int的结构体，手算一遍再用程序验证，这类选择题只要练过两三个例子就不会再错。

6. 考前冲刺复习清单：从错题本到上机环境的查漏补缺

最后这十几天，不要再从第一章读到最后一章，直接用查漏的方式推进。把复习分成两段：先按题型清查知识漏洞，再按套卷做上机模拟。

选择题的查漏办法是"三刷错题法"。第一刷把错题按章节归类，看看失分集中在语法题还是公共基础题；第二刷只做错过的题，做对标绿的跳过，做错标红；第三刷只做标红的题，做到能不看选项口头解释"为什么对、为什么错"为止。判断标准很简单：如果你能给别人讲清楚这道题，才算真的会了。对于程序填空和改错，冲刺期的重点不是多做新题，而是把做过的题重新默读一遍，问自己三个问题：空位处为什么填这个表达式、这段代码的边界条件是什么、如果删除某个语句程序会怎么跑。改错题里常见的错误类别就是第 5 章的六类，照着清单逐条排查即可。

程序设计题最后两周每天至少手写两道完整代码。重点是结构体链表和文件读写这类综合题，写完之后对照标准答案检查三处：指针有没有判空、循环边界有没有差一、文件用完有没有关闭并释放资源。上机环境要提前熟悉，至少做一次"从新建工程到运行调试"的完整流程，考场里最紧张的程序设计部分才不会在环境操作上浪费时间。

最后附一张冲刺任务表，考前两周按周拆开：

表格里的失分标准可以按自己水平调整，但"错题三刷"和"套卷按上机流程走"这两条不要跳过。公共基础那 10 分如果还没有整理成小卡片，考前一周抓紧用零碎时间背，它的性价比远高于临考前抠偏怪语法。

这里说一个我自己的教训：第二次备考时，我一度沉迷刷新题，选择题刷了上千道，但对错题只对答案不总结，最后上考场遇到同一考点的变体仍然在犹豫。后来我强迫自己每道错题都必须写下"考点 + 错误原因 + 一句话修正"，从那以后每次考前我都强制自己至少走一遍"看错题本 → 按易错清单自查 → 完整跑一套上机题"的流程，才把成绩稳定住。这套资料里的题库和知识点清单也是按这个思路整理的，配合上面的冲刺表用，希望帮到你。

本文还有配套的精品资源，点击获取