企业官网建设流程全解析

大家都知道 C 语言里指针是重点，也是难点，但"重点"和"难点"这两个词其实很空。真正让人卡住的，往往不是指针本身的语法，而是缺乏一个能把这些零散知识点串起来的实际任务。我当年在学《C 语言程序设计（第四版）》（何钦铭、颜晖主编）第十一章"指针进阶"时，就是卡在了一堆概念上：指针数组、指向指针的指针、字符串与指针的关系……说实话，光看书都能看懂，但一写代码就不知道从哪下手。后来是把"字符串连接"这道题反复做了七八遍，才把这一章的内容真正串了起来。这篇文章就想以字符串连接为主线，把指针进阶里那些最容易混淆、最值得抠的细节一次讲透。

字符串连接这个任务，放在第十一章而不是更早的章节，是有道理的。前面几章你可能已经用数组写过字符串拼接了，但那时候你用的大概率是"数组下标"思维；到了指针进阶，教材希望你把实现方式从"数组"切到"指针"，并且能说清楚这两种写法在内存层面究竟差在哪里。字符串连接这个任务虽然短，但它同时涉及字符串定位、字符搬运、结尾处理、边界条件、内存安全，几乎涵盖了指针操作字符串的所有核心场景。你要是能把一个 strcat 从头到尾用指针写明白，第十一章里后面那些概念回头看会顺畅很多。

我见过不少人学到这一章时，会写一个能跑但经不起问的版本：代码能输出正确结果，但你要是问他"为什么目标数组必须足够大""为什么函数要返回 char *""如果源字符串和目的字符串是同一个数组会怎样"，他就答不上来了。这篇文章会把这些问题一个个拆开，不光是给代码，还给内存图，给排查思路，给我在实际调试中踩过的坑。适合刚学完指针基础、正在啃指针进阶的读者，也适合已经工作但想把 C 语言底层基本功重新夯实的人。

1. 字符串连接这道题，为什么会放在"指针进阶"而不是"数组"章节

1.1 从"数组下标思维"到"指针算术思维"的跳跃

很多初学者会奇怪，字符串连接不就是把第二个字符串的内容追加到第一个字符串后面吗？用数组下标完全可以实现，为什么教材非要到指针进阶这一章才拿出来细致讨论？

原因是，数组下标写法在解决"已知长度的字符串连接"时很直观，但当字符串长度不定、内存区域复用、函数需要返回操作后地址等场景出现时，下标思维就很容易写出一堆问题代码。指针进阶的核心目标，是让你从"我按下标依次访问元素"升级为"我知道元素的地址，可以通过指针移动来遍历内存"，这两种写法表面上能达到同样效果，但底层逻辑完全不同。

举个例子，下面这两行代码，在功能上是等价的：

str[i] = 'A'; *(str + i) = 'A';

但从编译器的角度看，str[i]本质上就是*(str + i)的语法糖。下标写法把"移动指针再解引用"这个过程隐藏了，指针写法把这个过程显式地写出来。第十一章安排在数组之后，就是要让你逐渐摆脱"靠下标感觉"的舒适区，用"靠地址计算"的方式思考问题。而字符串连接，恰好同时涉及"找到目标字符串的结尾"和"逐个复制字符"这两个操作，前者可以练指针比较和条件判断，后者可以练指针自增和解引用，是练习指针算术最好的载体，没有之一。

1.2 完整字符串连接要经历哪三个阶段

把一个 strcat 拆开看，其实只有三个阶段：定位、搬运、收尾。但每个阶段都有坑。

定位阶段，需要找到目标字符串的终止符'\0'所在的位置。这是很多人写错的第一步——直接用strlen(dest)获取长度，然后下标定位到dest[strlen(dest)]。这样也行，但意味着你要遍历两次字符串，第一次数长度，第二次才开始复制。指针写法可以在一次遍历里完成定位，效率更高。

搬运阶段，把源字符串的字符逐个复制到目标位置，包括最后的'\0'。这一步最容易被忽略的是：你不仅要复制可见字符，还必须复制字符串结束符。如果漏了结尾的'\0'，函数返回后，调用方用printf("%s", dest)打印时会一路读到内存里的随机数据，直到运气好碰到一个 0 才停下来，表现就是输出后面跟了一堆乱码。

收尾阶段，返回目标字符串的首地址。这个返回值不是可有可无的，它让用户可以把多次连接嵌套起来写，比如strcat(strcat(a, b), c)。这个设计思路在标准库函数里很常见，理解它对你后面看其他库函数源码会有帮助。

2. 从零手写 strcat：下标版到指针版的演进，以及每一步的内存视角

2.1 下标版：先跑通功能，再问自己"还能怎么写"

很多教材或习题会让读者自己实现一个字符串连接函数，如果你还处于下标思维，通常会写成这样：

#include <stdio.h> void my_strcat(char dest[], const char src[]) { int i = 0, j = 0; while (dest[i] != '\0') { i++; } while (src[j] != '\0') { dest[i] = src[j]; i++; j++; } dest[i] = '\0'; } int main() { char str1[20] = "Hello "; char str2[] = "World"; my_strcat(str1, str2); printf("%s\n", str1); return 0; }

我建议你写完之后，画一张这次操作的内存布局图：str1占了多少字节，str2占了多少字节，i和j分别是多少，堆栈上有哪些变量。这个画图的过程比代码本身更有价值。等你能把内存图画明白，再往指针版本走。

下标版正确是正确，但它有两个问题：第一，它遍历了目标字符串两次（第一次数长度、第二次复制源字符串的开头可以从目标字符串的遍历结果中直接取到位置，但实际上下标版是把"找末尾"和"复制"分成了两个完全独立的循环，第二个循环又从头开始），效率上不如指针版一个循环边判断边移动；第二，它没有返回值，不便于链式调用。这两个问题，正好是指针版要解决的。

2.2 指针版：*to++ = *from++这行代码到底发生了什么

下面是指针进阶章节最经典的 strcat 实现：

char *my_strcat(char *dest, const char *src) { char *ret = dest; while (*dest != '\0') { dest++; } while ((*dest++ = *src++) != '\0') { ; } return ret; }

很多初学者看到第二个循环就懵了：*dest++ = *src++是什么意思？为什么循环体是空的？我用通俗的方式拆一下。

*dest++和*src++的优先级是这样的：++的优先级高于*，但由于++是后缀形式，所以它先返回变量当前值，再做自增。因此*dest++等价于*(dest++)，意思是"取出 dest 当前指向的位置，把 dest 向后移动一格，然后对取出的位置进行解引用"。用生活类比，就像你排队取餐：先看自己现在站在哪个窗口，记住这个窗口，然后往前挪一步，最后把手里拿到的餐放到刚才记住的那个窗口上。

所以*dest++ = *src++的完整执行顺序是：

1. 取出dst当前指向的地址，把它作为赋值的目标位置；
2. dst自增，指向下一个存储单元；
3. 取出src当前指向的地址，读取该地址上的字符；
4. src自增，指向源字符串的下一个字符；
5. 把第 3 步读到的字符赋给第 1 步记下的目标位置；
6. 整个赋值表达式的结果值，就是被赋进去的那个字符；
7. 把第 6 步的结果和'\0'比较，决定循环是否继续。

这七步，在一行 C 代码里全部完成了。如果你之前不理解为什么循环体可以写成空语句，现在应该明白了：判断条件和赋值副作用都在条件表达式里完成了。这种写法紧凑，但如果你是在团队项目里工作，我建议还是拆成多行，并加上注释，否则维护的人（包括三个月后的你自己）会看得头大。

2.3 面试和考试喜欢问的细节：函数签名、const、返回值和空指针

教材和标准库的strcat原型是：

char *strcat(char *dest, const char *src);

为什么要用const char *src而不是char *src？因为函数承诺不会修改源字符串的内容。这个const不只是给编译器看的，也是给读代码的人看的。你以后写自己的库函数时，只要某个参数是"只读"的，就应该加const，这是接口设计的好习惯。

为什么要返回char *？前面说了，为了链式调用。但还有一层原因：strcat的返回值是dest的原始值，不是操作结束后的指针。这一点很容易被忽略。如果你写成：

char *my_strcat(char *dest, const char *src) { while (*dest != '\0') dest++; while ((*dest++ = *src++) != '\0') ; return dest; // 错误，返回的是目标字符串末尾 }

函数返回后，你拿到的指针指向的是连接后字符串的'\0'位置，而不是开头。printf 直接用它输出，什么都打不出来。标准库返回原始值正是为了避免这种错误，同时让"返回目标字符串"这个语义更稳定。

还有一个重要问题：如果dest或src传入的是空指针，程序会崩溃。标准库的strcat没有对此做检查，因为 C 语言的设计哲学是"信任调用者"。你自己实现时，可以加一层判断：

if (dest == NULL || src == NULL) { return dest; }

但对于一个"教学函数"，我认为不加也行，反而能让你记住：调用任何 C 字符串函数前，必须确保指针有效。这个教训我在后面讲调试时会再提。

3. 字符数组与字符指针：为什么有人写char *p = "..."然后连接就崩了

3.1 字符串字面量、字符数组、字符指针三者的内存位置差异

这一节是本章最容易出现事故的地方，几乎每次上机课都有人在这里把程序写崩溃。

看下面三个定义：

char str1[] = "Hello"; char *str2 = "Hello"; const char *str3 = "Hello";

str1是一个字符数组，大小为 6 字节（五个字符加一个'\0'），它存储在栈上或者静态存储区（取决于你声明的位置）。数组名str1代表这个数组首元素的地址，你可以修改str1中的内容，比如str1[0] = 'h';。

str2是一个指向字符的指针，它指向的是字符串字面量"Hello"。问题在于，字符串字面量在内存中通常存放在只读区（很多编译器放在 .rodata 段）。你试图通过str2修改它，比如str2[0] = 'h';，在现代编译器和操作系统上，往往会直接触发段错误，程序崩溃。

str3加了一个const，明确告诉编译器"我不打算修改它"。这是最安全的一种写法，推荐在只读使用场景下采用。

回到字符串连接：如果你写成下面这样，程序大概率崩：

char *dest = "Hello "; char *src = "World"; strcat(dest, src); // 试图向只读区追加字符

为什么？因为dest指向的是一个字符串字面量，它处在只读区，而且"Hello " 后面那块内存是什么并没有保证，可能紧接着是其他只读数据。strcat 要往那里写"World"，操作系统直接拒绝。这个场景我在答疑时见过不下二十次，几乎所有初学者都会踩一次。

正确做法是给目标字符串预留足够的可写空间：

char dest[20] = "Hello "; char src[] = "World"; strcat(dest, src);

3.2 追加字符串的边界条件：目标缓冲区必须大到能放下两个字符串加一个结束符

缓冲区大小问题，比"只读区"更难排查。因为很多时候程序不崩溃，但行为诡异。

举个例子：

char dest[10] = "Hello "; char src[] = "World"; strcat(dest, src);

"Hello " 占 6 字节，加上 "World" 占 5 字节，再加结尾的'\0'一共需要 12 字节，但dest只有 10 字节。strcat 会继续往后写，覆盖掉dest数组之后栈上其他变量的内存。C 语言数组不检查越界，所以它"成功"了，但后果无法预料：可能覆盖了相邻变量、可能破坏了栈帧、可能程序运行到很后面才崩溃。这就是典型的"缓冲区溢出"。

备考或者刷题时，你只需要记住一个公式：

目标缓冲区可用长度 >= 目标字符串当前长度 + 源字符串长度 + 1（多出来的 1 给'\0'）

用更严谨的说法：dest指向的内存区域必须能够容纳连接后的完整字符串，包括结束符。判断是否越界，用sizeof(dest)不行，因为一旦dest作为函数参数传入，它退化成指针，sizeof只能得到指针大小（通常 8 字节），拿不到数组长度。这也是为什么很多库函数要额外接收一个"缓冲区大小"参数，比如 Windows 的strcat_s，或者你可以在自己的函数里传入dest_capacity。

3.3 数组名和指针真的等价吗

教材里常出现"数组名就是指针"这种简化的说法，但到了指针进阶阶段，这句话必须打折理解。

数组名arr在大多数表达式中会"退化"（decay）为一个指向首元素的指针，这是它和指针相似的地方。但有两个场景它们完全不同：

第一个是sizeof。sizeof(arr)返回整个数组的字节数，而sizeof(ptr)只返回指针本身的字节数。

第二个是取地址。&arr的类型是"指向整个数组的指针"，也就是char (*)[N]；而&ptr是"指向指针的指针"，也就是char **。这两者不是一回事。如果你定义了一个char arr[20]，然后在函数里试图用char **p = &arr;，编译器直接报错，因为类型不匹配。正确做法是char (*p)[20] = &arr;，这才是指向数组的指针。

在字符串连接这道题里，函数参数char *dest和调用时的char dest[20]之间的转换，背后就是"退化"规则。你传入数组名时，编译器自动把数组名转换成指向首元素的指针，函数内部拿到的是一个指针副本，不是数组本身。这也解释了为什么在函数里对dest做自增操作不会影响调用方的数组名——你改的是指针形参的副本，不是数组本身。理解这一点，你就不会写出"怎么函数返回后我的 dest 指针不移动"这种疑问了。

4. 从连接两个字符串到管理一堆字符串：指针数组与二级指针

4.1 用指针数组保存多条字符串

第十一章"指针进阶"里，字符串和指针结合的下一个层次，是用指针数组来管理多条字符串。比如：

char *keywords[] = { "C Language", "Pointer", "String", "Function" };

这里的keywords是一个数组，每个元素都是char *，指向一个字符串字面量。注意，这四条字符串本身的长度各不相同，但keywords数组的大小固定是 4 个指针元素（在 64 位系统上是 32 字节）。这种结构的好处是，比起char keywords[4][30]这种二维数组，指针数组不需要为每条字符串预留同样大的空间，内存利用率更高；但坏处是，这些字符串字面量其实不可修改，你只能读它们，不能原地写。

如果你想对keywords里的字符串进行排序或者拼接，就需要把可写内容复制到自己的缓冲区里。下面的代码演示了如何用"二维字符数组 + strcat"实现多段文本拼接：

#include <stdio.h> #include <string.h> int main() { char buf[128] = {0}; const char *parts[] = {"Hello", ", ", "world", "!"}; int n = sizeof(parts) / sizeof(parts[0]); for (int i = 0; i < n; i++) { if (strlen(buf) + strlen(parts[i]) + 1 > sizeof(buf)) { printf("缓冲区空间不足，操作终止\n"); return 1; } strcat(buf, parts[i]); } printf("%s\n", buf); return 0; }

这段代码里有几个值得注意的细节：

• buf[128]初始化为全 0，这保证即使你不主动设置'\0'，它也是空字符串；
• 拼接之前判断剩余空间，是防止缓冲区溢出的关键一步；
• sizeof(parts) / sizeof(parts[0])是数组元素个数的经典求法，但只适用于数组本身，不适用于函数参数里退化的数组形参。

4.2 二级指针作为函数参数：实现一个通用的字符串连接处理器

指针数组升级一步，就是二级指针。假设你要写一个函数，把多条字符串拼接起来，并且希望函数内部能修改传入的指针数组（比如先排序、再连接），这时参数就要用二级指针：

#include <stdio.h> #include <string.h> #include <stdlib.h> char *concat_all(char **strs, int n) { int total = 1; // 预留一个字节给结束符 for (int i = 0; i < n; i++) { total += strlen(strs[i]); } char *result = (char *)malloc(total); if (result == NULL) { return NULL; } result[0] = '\0'; for (int i = 0; i < n; i++) { strcat(result, strs[i]); } return result; } int main() { char *words[] = {"Pointer", "Advanced", "String", "Concat"}; char *joined = concat_all(words, 4); if (joined != NULL) { printf("%s\n", joined); free(joined); } return 0; }

char **strs这个参数，你可以这样理解：strs指向一个数组，数组里每个元素是char *。也就是"指针的指针"。在这个函数里，strs[i]取出的是一条字符串的首地址，strlen(strs[i])算出这条字符串的长度。二级指针在这里的意义是：你传入的是一个指针数组的首地址，而数组首地址本身也是一个指针，所以需要两层指针来引用它。

一个常见错误是把char **strs和char *strs[]混用。在绝大多数情况下，作为函数参数它们等价，因为数组形参也会退化成指针。但在定义变量时，char **strs是一个二级指针变量，char *strs[]是一个指针数组变量，两者不同。你可以这样记：函数参数里写char **strs还是char *strs[]，编译器都会把后者调整成前者，但你自己定义变量时，它们不通用。

4.3 动态内存版连接函数：malloc、realloc 与内存释放

上面的concat_all用malloc一次性分配了足够的空间。这种方法有个局限性：如果调用方不知道总长度，或者后续还要继续追加字符串，就需要用realloc动态扩容。

一个简单的"可追加字符串"工具函数长这样：

char *append_string(char *dest, const char *src) { if (dest == NULL) { dest = (char *)malloc(strlen(src) + 1); if (dest) strcpy(dest, src); return dest; } size_t new_len = strlen(dest) + strlen(src) + 1; char *temp = (char *)realloc(dest, new_len); if (temp == NULL) { return NULL; // 注意：扩容失败时 dest 仍然有效，但 temp 为 NULL } strcat(temp, src); return temp; }

你得特别注意realloc的语义：如果内存分配失败，返回NULL，但原来的内存块不会被释放。所以正确做法是先把返回值存到一个临时指针里，判断非空后，再赋给原来的指针，绝对不要直接写成dest = realloc(dest, new_len)。一旦 realloc 失败，dest被置成 NULL，原来的内存地址就找不到了，会造成内存泄漏，而且后续操作全乱套。

内存释放也是必须考虑的问题。每次malloc或realloc得到的内存，用完都应该free。在main函数里，调用完concat_all后要记得释放返回的内存；如果你调用append_string追加了很多次，最后同样要释放。指针进阶考试中，运行时崩溃很多就是因为忘了 free 或重复 free。

5. 字符串连接最常见的 Bug，以及我实际调试时用的三步定位法

5.1 症状一：程序编译通过，一运行就崩溃

这种崩溃最常见的原因，就是我前面提到的"目标字符串指向字符串字面量"。表现形式是：

char *a = "Hello "; char *b = "World"; strcat(a, b);

在 Linux 上用 gcc 编译，运行时通常出现Segmentation fault。在 Windows 上，如果你用 VS 或 CodeBlocks，可能弹出一个"程序已停止工作"的对话框。

我的定位方法很土，但极有效：在 strcat 前后各加一个 printf，打桩观察。如果前面能打印、后面崩了，说明问题就出在这个函数调用上。这时候再检查目标指针是否指向可写内存，十有八九能找到原因。

5.2 症状二：输出结果后面有乱码

如果你能看到连接后的内容，但后面跟着不明字符，通常是目标缓冲区没有正确设置结束符。比如你手写连接逻辑时只搬运了可见字符，忘了最后加'\0'。

定位方法：在输出前，用调试器查看dest的字节内容。以 gdb 为例：

gdb ./a.out (gdb) break main (gdb) run (gdb) x/20bx dest

x/20bx命令可以让你直接查看dest地址开始的 20 个字节。你数一下，如果第 11 个字节不是 0，说明结束符确实丢了。另一个办法是干脆用memset(dest, 0, sizeof(dest))先把整个缓冲区清空，这样即使你漏写了结束符，字符串也会在缓冲区末尾自然终止，问题不会暴露。不过这只是缓解手段，根本办法还是每次写字符串后都要记得收尾。

5.3 症状三：函数返回后，原来的指针"不走了"

有个同学问过我一个问题：为什么my_strcat(dest, src)执行完后，dest没有指向连接后的字符串末尾？我让他看函数原型，里面char *dest传的是指针的值，不是指针的引用。函数内部对dest自增，改变的是形参副本的值，不影响调用方的实参。如果你希望函数内部移动指针后，调用方也能感知，就必须传入char **dest，然后在函数内部用*dest去操作。

举个例子：

void move_to_end(char **p) { while (**p != '\0') { (*p)++; } }

调用时写move_to_end(&ptr);，这样才能改变调用方的ptr。这个知识点在第十一章后面链表、树的部分也会反复用到，值得现在就彻底搞清楚。

5.4 工具链辅助：gdb、printf、AddressSanitizer 的组合使用

平时我调试字符串相关代码，首选的不是 IDE 的图形化调试器，而是 gdb 加 printf 加编译器的地址消毒器（AddressSanitizer，简称 ASan）。

ASan 的使用非常简单，编译时加一个参数就行了（gcc 或 clang）：

gcc -g -fsanitize=address -fno-omit-frame-pointer -o test test.c ./test

如果你有越界读写或者使用了已释放内存，ASan 会给出非常详细的报告，包括是哪个线程、哪一行代码、访问了什么地址、这个地址周围是什么。它在定位缓冲区溢出问题上，比任何手打 printf 都高效。一个建议是：只要在开发阶段，都把这个选项开着，等代码稳定了再关掉。字节序、内存对齐这类问题虽然不在字符串连接的范围里，但 ASan 这个工具以后写 C 代码都用得上。

6. 教材之外，我建议你动手练的几道配套练习

6.1 自己实现一个带"安全边界"的 strcat_safe

教材里的 strcat 没有容量参数，也就无法做边界检查。你可以自己定义：

int strcat_safe(char *dest, size_t dest_size, const char *src)

返回值用 0 表示成功，-1 表示失败。函数内部先计算dest已有长度和src长度，如果两者之和加 1 超过dest_size，直接返回 -1，不执行任何写入。这个练习的价值在于：让你从"功能实现"升级到"接口设计"，理解为什么现代 C 标准库要推出一系列_s后缀的安全函数。

6.2 用指针方式实现字符串逆序

字符串逆序是 PTA 上非常常见的练习题，网上搜"C语言字符串逆序 PTA"能搜到一大把。但它和字符串连接结合起来的练习更有意思：先连接两个字符串，再对结果做原地逆序。这个练习能同时练到"指针移动"和"交换字符"两个操作。

核心伪代码：

void reverse(char *str) { char *left = str; char *right = str + strlen(str) - 1; while (left < right) { char temp = *left; *left++ = *right; *right-- = temp; } }

注意left < right这个判断条件是靠指针比较实现的，不能当作整数比较。C 标准里，指向同一个数组内元素的指针才能用关系运算符比较，这里的 left 和 right 指向同一个字符串数组的不同元素，符合规则。

6.3 用文件读写练字符串拼接的完整落地

光在内存里拼接字符串，总觉得少了点实际场景。我建议你做一个练习：从一个文本文件读取多行内容，把它们按顺序拼接成一个长字符串，前两行之间用逗号分隔，最后把结果写入另一个文件。这个题目在网上搜索"c语言文件读写操作代码"能找到很多参考，但关键是你要自己动手，把字符串连接和fopen、fgets、fputs或fprintf组合起来用。

这里有一个容易踩的坑：fgets会把换行符也读进缓冲区。如果你不做处理，直接拼接，得到的长字符串中间会夹杂着换行。处理方式是：

line[strcspn(line, "\n")] = '\0';

strcspn(line, "\n")返回line中第一个'\n'的下标，把那个位置替换成'\0'，就把换行符去掉了。这个技巧可以说是文件行读取中最常用的处理之一，比手动循环查找换行符省事得多。

6.4 VS Code 环境配置对学指针的帮助

很多初学者在 Windows 上用 VS Code 学 C，但只配了编译，没配调试，导致出了 Bug 只能瞎猜。建议把 VS Code 的 C/C++ 扩展装好，学会在launch.json里调用 gdb 或 lldb，并且熟练使用"添加监视"功能，实时查看指针变量的值和它指向的内容。具体配置方法网上搜"vscode c语言环境配置"有很多教程，我这里只提醒三点：

第一，tasks.json里编译命令要加-g选项，否则没有调试符号，断点和监视都无法正常工作。第二，调试时要在监视窗口输入*(char (*)[20])dest这样的类型转换表达式，才能完整查看一个 20 字节数组的内容，直接看 dest 只能看到第一个字符。第三，如果使用 VSCode 的集成终端运行程序，遇到中文编码问题，往往是终端代码页和源文件编码不一致，可以在设置里把"terminal.integrated.profiles.windows"的编码调成 UTF-8，或在tasks.json里加-fexec-charset=UTF-8。

这些环境细节属于"必要但不紧急"的内容，但它对你的学习效率影响非常大。我在带了几年新生之后发现，指针学得好的学生，往往不是智商多高，而是能熟练使用调试器，能在崩溃的第一时间看到调用栈和变量值，能快速从"现象"跳到"原因"。这才是程序设计的核心能力。

字符串连接这道题，看起来只是十几行代码，但如果你愿意把上面这些点都验证一遍，你的指针水平会有一个肉眼可见的进步。你不需要一次性全做完，可以先挑一个自我感觉最模糊的点下手。比如现在立刻打开编辑器，把char *dest = "Hello "改成可写的数组版本，再用 gdb 或者 ASan 观察一下区别。动手试过之后，你再来回头看书里第十一章后面那些概念，会发现轻松很多。