在过去的十多年里，你一定遇到过各种各样“不安全”的网页提示。每当这时，是选择“小心驶得万年船”默默退出，还是“猛击”一下继续访问？

但无论你怎么选，有没有想过：这些烦人的提示到底是怎么来的？ 如果我硬要访问，提示里说的风险真的会发生吗？

你可能简单搜了一下，了解到这和 HTTPS 有关。可惜搜到的结果里夹杂着一些难懂的名词，比如 SSL、CA 机构等等，让人头大。甚至还有一些“大聪明”的帖子，教你如何手动关掉这些提示。但是去除了提示，可不等于去除了风险，这跟掩耳盗铃没啥区别。

要想真正提升网上冲浪的体验和安全感，就有必要搞懂 HTTPS 是如何保护我们的，以及数字证书在其中扮演了什么角色。更有趣的是，深挖下去，你会发现这与区块链技术也颇有渊源。

HTTP：那个在互联网上“裸奔”的协议

访问一个网站很简单，在浏览器输入网址，回车，搞定。但你想过吗？数据在你和网站服务器之间，经历了几十上百次的路由跳发。

比如，一个上海的用户访问北京的服务器，数据包中间可能要经过好多个路由器节点。在这么大的地理跨度下，谁能保证中间会不会有黑客在窃听，甚至篡改你的数据呢？

这就好比你给远方的朋友寄快递，路上谁都可能偷看一眼，甚至把你买的手办换成一块板砖。

图片来源：gemini Banana 模型生成，仅供参考

这背后的根本原因，是 HTTP 协议本身就是“裸奔”的——它压根没考虑安全问题，所有数据都以明文的形式传来传去。这让攻击者几乎不费吹灰之力就能监听和篡改。

更有甚者，早些年一些不讲武德的网络运营商，还会利用职务之便搞数据劫持，在你访问的网页里强行插入广告弹窗。所以那几年我们经常会看到，不管打开哪个网站，右下角总有那么些“狗皮膏药”广告。

HTTPS：给数据穿上“金钟罩”

上世纪 90 年代中期，互联网的价值越来越大，大家终于意识到，得给 HTTP 这个“裸奔”的协议加点安全保障了。

第一个吃螃蟹的是当时的大佬——网景公司（Netscape）。他们在 1994 年率先在自家浏览器里实现了 HTTPS 协议，这个 S 就代表 安全（Secure）。

实现方法也很直接：加密。先对数据加密再传输，对方收到后解密再用。这样一来，数据虽然还是要走过千山万水，但攻击者看到的只是一堆乱码，无可奈何。

加密的烦恼：密钥怎么悄悄给？

我们知道的加密算法有很多，从凯撒密码到二战时期的恩尼格玛机，再到现代的 DES 算法。但它们都有一个棘手的问题：都需要密钥。

加密和解密必须用同一个密钥，这叫对称加密。

问题来了：浏览器和服务器怎么才能安全地商量出一个只有他俩知道的密钥呢？如果一方生成了密钥，直接明文发给对方，那中间的攻击者不就也轻松截获了吗？这加密不就成了个寂寞？

总不能每次上网，都坐火车去和网站站长线下接头对暗号吧？这显然不现实。

神来之笔：非对称加密

更实际的办法是非对称加密。

跟对称加密用同一个密钥不同，非对称加密的密钥总是成对出现的，一个叫公钥，一个叫私钥。

它们的规则是：

• 用公钥加密的数据，只能用对应的私钥解密。
• 用私钥加密的数据，只能用对应的公钥解密。

这个过程是不对称的，非常奇妙！

有了这个神器，密钥交换问题就迎刃而解了：

1. 服务器先把自己的公钥发给浏览器（公钥是公开的，谁拿到都无所谓）。
2. 浏览器随机生成一个用于对称加密的密钥（我们叫它“会话密钥”）。
3. 浏览器用服务器的公钥，把这个“会话密钥”加密，再发给服务器。
4. 服务器收到后，用自己的私钥解密，就得到了“会话密钥”。

这样，浏览器和服务器就有了一个共同的、谁也偷不走的密钥。在这个过程中，就算攻击者截获了服务器的公钥和被加密后的会话密钥，也白搭，因为他没有服务器的私钥，根本解不开！

用非对称加密来协商出一个对称加密的密钥，然后再用这个密钥进行真正的数据传输，这就是 HTTPS 协议里那个 S 的大致实现原理。这套独立于 HTTP 的流程，也被称为 SSL（安全套接字层），而这个密钥协商的过程，就是大名鼎鼎的 SSL 握手。

小插曲：从 SSL 到 TLS

从 1994 年到 1996 年，SSL 经历了 1.0 到 3.0 的升级。后来，互联网工程任务组（IETF）决定把它标准化，于 1999 年发布了一个新名字 TLS。所以很多人也把 TLS 1.0 看作是 SSL 3.1。这两个名字后来也经常混用。顺便一说，改名也让当时和网景打得不可开交的微软显得不那么 loser 了（笑）。

后来 TLS 也一路升级到 1.3，主要是修补安全细节，比如在 TLS 1.2 中淘汰了逐渐不安全的 MD5 和 SHA-1 哈希算法，换上了更强的 SHA-256。

道高一尺，魔高一丈：中间人攻击

问题似乎完美解决了，但仅仅是“似乎”。

这里面还有一个致命的漏洞：如果在第一步，服务器给浏览器发公钥的时候，攻击者就把它拦截下来，换成自己的公钥，再发给浏览器，会怎么样？

浏览器并不知道公钥被掉了包，于是开心地用攻击者的公钥加密了会话密钥。攻击者截获后，用自己的私钥轻松解密，就拿到了会话密钥！然后，他再用之前截获的服务器的真公钥，把会话密钥加密一遍发给服务器。

在这个过程中，浏览器和服务器都以为自己在和对方安全通信，但其实他俩的密钥，攻击者也一清二楚。后续所有的加密，都成了皇帝的新衣。

网站的“身份证”：数字证书与 CA 机构

这个问题的根本在于，一个公钥本身，并不能证明它属于谁。

解决方案是引入一个权威的第三方。现在，服务器不直接给公钥了，而是把自己的公钥、域名、公司信息等打包，去找一个叫 CA（Certificate Authority，证书颁发机构）的第三方。

CA 机构在严格核实了服务器的身份后，会用自己的私钥对这份数据包进行加密（这个过程叫签名）。最后，这个“被签了名的数据包”就是数字证书。

现在，服务器传递给浏览器的，就是这份能证明自己身份的证书。

浏览器拿到证书后，不会直接相信，而是要先验证：

1. 浏览器内置了所有受信任的 CA 机构的公钥。
2. 浏览器找到证书里写的那个 CA 机构，用它对应的公钥去解密证书里的签名。
3. 如果解密后的数据和证书里的明文数据对得上，并且证书里的域名和当前访问的域名也一致，验证通过！

这样一来，浏览器就能百分百确定，证书里的公钥确实是这个网站的，而不是攻击者伪造的。中间人攻击的“偷天换日”大戏就演不下去了。

谁是 CA？我们为什么信它？

能成为 CA 机构的，都是像微软、谷歌、Symantec、DigiCert 这样有影响力的权威机构或专业的安全公司。原则上，它们没有动机去颁发假证书，因为这会砸了自己的金字招牌。

你的操作系统和浏览器出厂时，就已经内置了一份“受信任的根证书颁发机构”列表。只有这个列表里的 CA 签发的证书，才会被承认。前些年有些网站自己给自己发证书（自签名证书），浏览器压根不认，就会弹出安全警告。

中心化的软肋：当权威不再权威

到这里，事情好像真的解决了。但你有没有发现，CA 机构的权力和责任实在太大了，导致整个安全体系都建立在对它的信任之上，这其实很脆弱。

达摩克里斯之剑并未消失，只是向旁边挪了几寸。

证书的颁发最终还是要靠人来判断，是人就可能犯错，也可能被收买。

• 2015 年，谷歌 vs 赛门铁克：谷歌发现 CA 巨头赛门铁克偷偷给谷歌的域名签发了错误的测试证书。虽然赛门铁克解释说是内部测试，但谁能保证这种证书不会泄露出去呢？
• 2017 年，信任危机：谷歌在调查后，宣称赛门铁克错误地颁发了至少 3 万个证书，并最终在 Chrome 浏览器中全面“拉黑”了赛门铁克的证书。
• 棱镜门：虽然没有直接证据，但人们有理由担心，政府机构可以利用权力强迫 CA 机构颁发假证书，以用于监控。

这些事件暴露了中心化 CA 机制的困境：利益、人为因素，都是无法根除的问题。

终极方案？证书透明度（CT）

正是在这样的背景下，证书透明度（Certificate Transparency, CT）方案应运而生。

这个机制的核心逻辑，一句话概括就是：引入公开的、可审计的、去中心化的日志。

1. 现在，CA 机构每次颁发一个证书，都必须强制性地向一个公开的日志服务器提交证书信息。
2. 日志服务器记录下来，并返回给 CA 一个SCT（Signed Certificate Timestamp，签名证书时间戳）。
3. CA 必须把这个 SCT 也打包进最终的证书里。
4. 当浏览器收到证书后，除了验证 CA 的签名，还要拿着 SCT 去日志服务器验证，确认这份证书确实被公开记录过。

你可能会问，这不就是套娃吗？CA 会出错，日志服务器就不会吗？

这就是 CT 机制最妙的地方：去中心化和防篡改，而这背后用到的正是类似区块链的技术——默克尔树（Merkle Tree）。

简单来说，日志服务器把所有证书记录通过哈希运算，构建成一棵“哈希树”。任何一条记录的微小改动，都会像蝴蝶效应一样，层层传导，最终导致树顶的根哈希值发生巨大变化。

这个账本是只能添加、无法篡改的，而且完全公开。任何人，包括域名所有者（可以扮演“监视者”的角色），都可以随时查询这个公开账本，检查有没有人背着自己，给自己的域名申请了可疑的证书。

从 2018 年开始，Chrome 和 Safari 等主流浏览器已经强制要求证书必须包含 SCT 信息，否则一律标为不安全。这样，所有 CA 机构都被纳入了这个公开的监管体系，再也不能“暗箱操作”了。

结语：永不消失的达摩克里斯之剑

至此，HTTPS 的安全机制，在加入了 CT 之后，基本上算是最接近完美的方案了。

但和所有安全问题一样，完美就像一个极限，只能无限趋近，却无法真正到达。CT 机制本身也存在一些理论上的风险，比如日志服务器作恶、监视者失职等等。

网络安全就是一场永无止境的攻防博弈。或许，那把悬在头顶的达摩克里斯之剑永远无法彻底消失，但经过这么多年的努力，一代代技术先驱们，已经成功地将它安放到了一个相对安全的距离之外。

而我们作为用户，下一次再看到“不安全”的提示时，或许能多一份理解和从容。

参考文献
[1] Wikipedia. Transport Layer Security [EB/OL]. [2023-03-05]. https://en.wikipedia.org/wiki/Transport_Layer_Security.
[2] transparency.dev. How CT fits into the wider WebPKI ecosystem [EB/OL]. [2023-03-12]. https://certificate.transparency.dev/howctworks/.
[3] Google. How CT Works [EB/OL]. [2023-03-10]. https://sites.google.com/site/certificatetransparency/how-ct-works.
[4] 张婕, 王伟, 马迪, 等. 数字证书透明性 CT 机制安全威胁研究[J]. 计算机系统应用, 2018(10).

如果你和曾经的我一样，每次看到正则表达式都头皮发麻，那这篇文章就是为你准备的。

别怕，正则表达式没那么玄乎。说白了，它就是一种超强的文本“查找与替换”工具。小到检查用户输入的邮箱格式是否正确，大到从上万行日志里捞出你想要的那条信息，都离不开它。它就是程序员处理文本的瑞士军刀。

这篇指南不会讲得天花乱坠，只讲最常用、最核心的那些部分，保证你能快速上手，解决掉 80%的日常问题。

热身运动：找个好用的“游乐场”

在正式开干前，你需要一个能随时测试你想法的地方。别总是在 IDE 或代码里print调试，效率太低。

强烈推荐 **regex101.com**。

这网站好在哪？它不光能告诉你匹配对了没，还会在右边把你的表达式拆开来，告诉你每一步都是什么意思。对于新手来说，这简直是神仙功能。后面我们的所有例子，你都可以直接复制进去自己试试看。

核心招式：基础语法

掌握下面这几招，你就已经入门了。

1. 限定符：控制出现的次数

这是正则表达式最基本的功能。

• ? 问号：代表“可有可无”，也就是出现 0 次或 1 次。比如colors?可以同时匹配color和colors。
• * 星号：代表“随便来”，出现 0 次、1 次或很多次都行。比如ab*c可以匹配ac、abc、abbbbc。
• + 加号：和星号很像，但代表“至少要有一个”，也就是出现 1 次或很多次。ab+c就没法匹配ac了。
• {} 花括号：让你精确控制次数。
  • a{3}：不多不少，必须是 3 个 a。
  • a{2,5}：最少 2 个，最多 5 个 a。
  • a{2,}：最少 2 个，上不封顶。

2. 分组与分支：处理组合与多选

• () 括号：把一堆东西包起来，当成一个整体。比如你想匹配好几个连续的ab，就要用(ab)+，这样+才会作用于整个ab。
• | 竖线：代表“或者”。I love (cats|dogs)就能匹配I love cats和I love dogs。注意括号是必须的，不然就变成I love cats或者dogs了，意思全变了。

3. 字符类：指定一个范围

[]方括号允许你自定义一个“字符集合”，只要字符属于这个集合，就能匹配。

• [abc]：匹配 a、b、c 中的任意一个。
• [a-z]：匹配所有小写字母。
• [a-zA-Z0-9]：匹配所有字母和数字。
• [^0-9]：开头的^表示“取反”，所以这个是匹配所有非数字的字符。

4. 元字符：常用的“简写”

正则表达式的设计者早就为我们准备好了一些常用的字符类简写，省得我们每次都写方括号。

• \d：任意数字，相当于[0-9]。
• \w：任意“单词”字符，包括字母、数字和下划线，相当于[a-zA-Z0-9_]。
• \s：任意空白，包括空格、Tab、换行符。
• . (英文句点)：这是个大杀器，能匹配除了换行符之外的任何单个字符。
• \D, \W, \S：用大写字母表示对应小写版本的“取反”。比如\D就是匹配任意非数字字符。

5. 定位符：锚定位置

这些符号不匹配任何字符，而是匹配一个“位置”。

• ^：锚定一行的开始。^Hello只会匹配以 Hello 开头的行。
• $：锚定一行的结束。world$只会匹配以 world 结尾的行。
• \b：锚定一个单词的边界。用\bcat\b就能只匹配单词cat，而不会匹配到concatenate里面的 cat。

进阶心法：贪婪与懒惰

这是很多人刚开始会踩的坑。默认情况下，正则表达式是“贪婪”的。

什么意思？比如你有这么一段文本：

1

<span><a>link</a></span>

你想用<.+>来匹配 HTML 标签。你以为它会匹配出<span>和<a>和</a>和</span>。但结果是，它会从第一个<一直匹配到最后一个>，把整个字符串全给你。

这就是“贪婪”，+和*会尽可能多地吞掉字符。

解决方法很简单：在+或*后面加个?，让它变得“懒惰”。

用<.+?>，正则表达式就会在找到第一个匹配的>时立刻停下来。这在处理 HTML、XML 这类成对标签的文本时，几乎是必备技巧。

实战演练

理论讲完了，来点实际的。

场景一：提取十六进制颜色值

比如，从一堆 CSS 代码里找出所有像#ff6600这样的颜色值。

1. 颜色以#开头。
2. 后面跟着 6 个十六进制字符，也就是0-9或a-f（大小写不限）。
3. 我们希望它是个独立的单位，不希望匹配到#ff66000里面去。

组合起来就是：#([0-9a-fA-F]{6})\b

• #匹配井号。
• [0-9a-fA-F]定义了十六进制字符集。
• {6}表示要 6 个。
• \b定义了单词边界。

场景二：校验 IP 地址

这个需求很常见，但也更复杂。一个简单的\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}能匹配上格式，但它也会让999.999.999.999这样的鬼东西通过，因为 IP 地址每一段的范围是 0-255。

要精确匹配，表达式会变得有点吓人。别怕，我们拆开看。

1

\b((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\b

这个表达式的核心就是用|把 0-255 分成了几个区间来匹配：

• 25[0-5]：匹配 250-255
• 2[0-4]\d：匹配 200-249
• 1\d{2}：匹配 100-199
• [1-9]?\d：匹配 0-99

然后用分组和{3}把它重复三次，再跟上最后一段。这个例子有点劝退，看不懂没关系，先理解思路，需要用的时候再回来查就行。

总结与展望

到这里，你已经掌握了正则表达式的绝大部分精华。下面这张表可以当做你的备忘录。

正则表达式能做的远不止这些，还有捕获组、反向引用、零宽断言等更高级的玩法，那些可以让你写出更精妙、更高效的表达式。不过饭要一口一口吃，先把今天学的这些在实际项目中用起来，你会发现处理字符串的效率大大提升。如果感兴趣的话后续可能会在出几篇相关的博客。

如果你想继续深入，下面这几个资源质量非常高：

• **正则表达式 30 分钟入门教程**：中文启蒙经典，作者 deerchao。
• **Regular Expressions Tutorial **：英文世界的百科全书，极其详尽。

去动手试试吧，这才是掌握一门技术的最好方式。

导言

无论你是追番多年的老粉，还是刚入坑的新手，这篇文章将带你穿越 2003 年至 2025 年的动漫时光隧道，探索 50 部经典之作。这些作品不仅定义了时代，还为观众带来了欢笑、泪水和深刻思考。准备好纸巾和爆米花，一起开启这场动画盛宴！

这份榜单基于个人喜好，每部作品因其独特的故事、角色或情感共鸣入选。如果你的心头好未上榜，可能是尚未欣赏，或留待未来推荐。动漫的魅力在于多样性，无论是热血战斗还是温馨日常，总有一部能触动你。让我们放下成见，共同探索！

2003 年

《钢之炼金术师》（2003 版）

2003 版的《钢之炼金术师》以原创剧情脱颖而出。由于漫画未完结，动画中期走上原创道路，呈现黑暗、成人的基调。爱德华和阿尔冯斯兄弟为复活母亲付出沉重代价，一个失去四肢，一个灵魂寄宿盔甲。故事深入探讨“等价交换”的残酷真相，人造人的悲剧设定和孤独旅途令人动容，结局引人深思，留下“意难平”。
观看建议：搭配 2009 版《钢之炼金术师 FA》观看，两种风格各有千秋。
参考链接： 钢之炼金术师 (2003)

2006 年

《死亡笔记》

《死亡笔记》是智斗动画巅峰，讲述自诩“新世界之神”的夜神月与侦探 L 的惊心动魄对决。剧情扣人心弦，“薯片计谋”和网球赛场景将紧张感拉满。作品不仅是悬疑动画，更是对人性、正义和傲慢的深刻思辨，挑战权力边界。
观看建议：极为烧脑，建议专注观看，避免分心。
参考链接： 死亡笔记

2007 年

《Clannad》

《Clannad》表面是校园后宫喜剧，实为关于成长、家庭和失去的深刻作品。第一季通过冈崎朋也与女孩的互动，串联小镇与家族温馨主题。第二季《Clannad: After Story》描绘从校园到社会、从恋人到夫妻的现实人生，以温柔又残忍的方式讲述责任与亲情，让人泪流满面。
观看建议：第一季为第二季铺垫，务必完整观看，备好纸巾。
参考链接： Clannad

2009 年

《轻音少女》

京都动画的《轻音少女》以五位性格迥异的女孩和濒临废部的轻音社团为主线，定义“日常系”动画。故事围绕喝茶、吃蛋糕、卖萌和偶尔排练，捕捉青春期独一无二的闪光感，传递与朋友做喜欢的事的幸福。
观看建议：放松心情，享受青春的下午茶。
参考链接： 轻音少女

《钢之炼金术师：兄弟情》

《钢之炼金术师：兄弟情》（FA）是忠于漫画的少年热血完全体。故事从爱德华兄弟寻宝之旅扩展到国家阴谋，角色饱满，智商在线，战斗燃爆，情感感人，结局酣畅淋漓，堪称“六边形战士”。
观看建议：适合热血和深度剧情爱好者，直接入坑。
参考链接： 钢之炼金术师

《化物语》

《化物语》是新房昭之与西尾维新联手的奇特作品，围绕阿良良木历帮助被怪异附身的少女。信息量爆炸的对话、文字游戏台词和 45 度倾斜镜头带来震撼体验，非传统打怪升级。
观看建议：开启弹幕或 0.5 倍速，跟上密集对话。
参考链接： 化物语

2011 年

《命运石之门》

《命运石之门》需耐心，前期中二对话为后期惊天反转铺垫。第 12 集起剧情急转，探讨时间悖论和冈部伦太郎的痛苦抉择，成长从逗比到英雄，堪称教科书级剧情。
观看建议：坚持前 12 集，迎接过山车剧情。
参考链接： 命运石之门

《我们仍未知道那天所看见的花的名字。》

“面码找到你了！”这句台词让无数观众泪崩。《未闻花名》讲述因童年伙伴面码去世而疏远的朋友，在面码幽灵出现后解开心结，精准捕捉青春期敏感友情，治愈又催泪。
观看建议：适合情感深度爱好者，准备被感动。
参考链接： 未闻花名

2012 年

《冰菓》

《冰菓》将日常推理做到极致，千反田爱瑠的好奇心让折木奉太郎的高中生活多姿多彩。京都动画以神级演出赋予平凡小事悬念和美感，男女主暧昧互动心动不已。
观看建议：适合细腻剧情和青春氛围爱好者。
参考链接： 冰菓

《刀剑神域》

2012 年的《刀剑神域》开创“困在游戏世界”热潮。桐人双刀流和与亚丝娜的爱情感动无数观众，死亡游戏紧张感至今无人超越，是许多人入宅之作。
观看建议：适合冒险和浪漫爱好者，感受虚拟世界魅力。
参考链接： 刀剑神域

《中二病也要谈恋爱！》

《中二病也要谈恋爱！》将“中二病”化为笑中带泪的恋爱喜剧。前中二患者勇太与“邪王真眼”六花碰撞出笑料和感动，恋爱如打副本，羞耻又甜蜜。
观看建议：适合轻松浪漫喜剧爱好者，准备笑到捶床。
参考链接： 中二病也要谈恋爱！

2013 年

《玉子市场》

《玉子市场》是京都动画温馨日常之作，围绕饼店女孩玉子和会说话的胖鸟，充满生活气息和奇妙幻想，商店街人情味如热可可般治愈。
观看建议：看完 TV 版，务必看剧场版《玉子的爱情故事》。
参考链接： 玉子市场

2014 年

《乒乓》

汤浅政明的《乒乓》以狂放画风和张力分镜，讲述乒乓球背后的天赋、努力和友情。角色挣扎真实可感，“英雄登场”令人热泪盈眶。
观看建议：勿被画风劝退，适合深度体育番爱好者。
参考链接： 乒乓

《月刊少女野崎君》

《月刊少女野崎君》是反套路恋爱喜剧，元气少女千代告白却得签名，作品将少女漫画浪漫桥段沙雕演绎，全员活宝，笑点密集。
观看建议：适合放松大笑的观众，准备被逗乐。
参考链接： 月刊少女野崎君

《寄生兽》

《寄生兽》通过泉新一与寄生生物米奇的共生，探讨生命与人性。新一从胆小少年成长为冷酷战士，引发“恶魔”与“人类”思考。
观看建议：适合哲学与动作结合爱好者，准备三观重塑。
参考链接： 寄生兽

《四月是你的谎言》

《四月是你的谎言》以音乐为媒介，讲述天才钢琴少年有马公生遇小提琴手宫园薰，找回色彩。音乐与画面天衣无缝，每场演奏是情感爆发。
观看建议：适合音乐与青春故事爱好者，准备甜虐切换。
参考链接： 四月是你的谎言

2015 年

《干物妹！小埋》

《干物妹！小埋》外是完美美少女，回家变沉迷游戏薯片的“干物妹”，反差萌击中内心，纯粹解压喜剧。
观看建议：适合放松大脑，享受欢乐。
参考链接： 干物妹！小埋

《鲁邦三世》（2015）

2015 年《鲁邦三世》以意大利为舞台，融合盗宝与悬疑。新角色瑞贝卡带来化学反应，爵士乐带来浪漫与不羁。
观看建议：适合冒险与风格化动画爱好者。
参考链接： 鲁邦三世 Part IV

《一拳超人》

《一拳超人》以埼玉一拳解决敌人的设定解构英雄主义，烦恼不是怪人而是超市特卖。Madhouse 顶级作画带来双重享受。
观看建议：适合热血与幽默爱好者，准备被爽到。
参考链接： 一拳超人

2016 年

《Re:从零开始的异世界生活》

《Re:从零开始的异世界生活》重新定义穿越残酷。昴仅靠“死亡回归”，用无数死亡换取拯救机会，绝望与勇气交织，雷姆不可错过。
观看建议：适合情感冲击爱好者，准备被虐心。
参考链接： Re:从零开始的异世界生活

《在下坂本，有何贵干？》

《在下坂本，有何贵干？》将“装酷”化为艺术，坂本以匪夷所思方式化解一切，剧情离谱但爽快，纯粹搞笑佳作。
观看建议：适合轻松一笑，喝水时慎看。
参考链接： 在下坂本，有何贵干？

《3 月的狮子》

《3 月的狮子》讲述孤独职业将棋手桐山零在川本三姐妹温暖下走出阴霾。Shaft 天马行空画面具象化抑郁，治愈又深刻。
观看建议：适合心理描写爱好者，感受温柔与坚韧。
参考链接： 3 月的狮子

2017 年

《小林家的龙女仆》

《小林家的龙女仆》讲述龙女托尔为报恩成社畜小林女仆，带来性格各异龙伙伴。京都动画细腻作画展现跨越种族温馨日常，康娜萌点无法抗拒。
观看建议：适合治愈与奇幻爱好者，享受家庭温暖。
参考链接： 小林家的龙女仆

《来自深渊》

《来自深渊》以童话画风掩盖残酷世界观，莉可和雷格探索充满奇幻与诅咒的深渊，每步伴随血腥代价，震撼人心。
观看建议：适合硬核冒险爱好者，深夜慎看。
参考链接： 来自深渊

2018 年

《紫罗兰永恒花园》

京都动画的《紫罗兰永恒花园》被誉为“写给世界的情书”。前战争机器薇尔莉特通过书写信件理解“爱”，每集如电影般精良，催泪又治愈。
观看建议：适合情感深度爱好者，准备被感动。
参考链接： 紫罗兰永恒花园

《灵能百分百》

《灵能百分百》讲述超能力少年影山茂夫成长故事，顶级打斗作画包裹温柔内核，强调善良与勇气。
观看建议：适合动作与成长主题爱好者，享受视觉盛宴。
参考链接： 灵能百分百

《碧蓝之海》

《碧蓝之海》是爆笑青春喜剧，表面讲潜水，实为大学生喝酒与沙雕日常，无下限搞笑展现大学生活荒诞乐趣。
观看建议：适合放松大笑，准备笑出腹肌。
参考链接： 碧蓝之海

《强风吹拂》

《强风吹拂》是群像体育剧，十个背景各异大学生为箱根驿传奋斗，细腻描绘坚持与目标。
观看建议：适合励志故事爱好者，看完想穿跑鞋。
参考链接： 强风吹拂

《青春猪头少年不会梦到兔女郎学姐》

《青春猪头少年不会梦到兔女郎学姐》以量子力学与青春期综合症为内核，梓川咲太帮助患怪病的樱岛麻衣，机智对话和深刻人物塑造令人印象深刻。
观看建议：适合浪漫与超自然爱好者，享受智商在线剧情。
参考链接： 青春猪头少年不会梦到兔女郎学姐

2019 年

《辉夜大小姐想让我告白》

《辉夜大小姐想让我告白》将恋爱拍成史诗战争片，白银御行与四宫辉夜为让对方先告白展开高能智斗，藤原千花混沌加入笑点翻倍。
观看建议：搭配弹幕，吐槽比正片精彩。
参考链接： 辉夜大小姐想让我告白

《鬼灭之刃》

《鬼灭之刃》凭飞碟社变态级制作成现象级作品，第 19 集“火之神神乐”震撼视听，炭治郎为救妹妹踏上斩鬼之路，感人至深。
观看建议：适合热血与感动爱好者，准备被燃到。
参考链接： 鬼灭之刃

《 石纪元》

《 石纪元》让观众爱上科学，千空从石器时代重建文明，充满探索乐趣和创造豪情，知识量暴增。
观看建议：适合科普与冒险爱好者，感受科学魅力。
参考链接： 石纪元

《冰海战记》

《冰海战记》是史诗级作品，第一季聚焦托尔芬复仇，第二季转向赎罪与和平，立意深刻，令人震撼。
观看建议：适合历史与深度爱好者，两季不可错过。
参考链接： 冰海战记

2020 年

《别对映像研出手！》

汤浅政明的《别对映像研出手！》是献给动画爱好者的情书，三位少女凭热情与想象力创造动画，画面天马行空，展现创作魅力。
观看建议：适合创意与艺术爱好者，感受动画魔力。
参考链接： 别对映像研出手！

《咒术回战》

《咒术回战》是新时代少年漫标杆，MAPPA 精良制作带来时髦人设与流畅打斗，五条悟“无量空处”燃爆全场，角色魅力十足。
观看建议：适合动作与幽默爱好者，入坑首选。
参考链接： 咒术回战

2021 年

《赛马娘 第二季》

《赛马娘 第二季》以东海帝皇为主角，讲述传奇赛马起伏人生，永不放弃精神令人动容，热血催泪奇迹之作。
观看建议：无需看第一季，直接入坑，准备被感动。
参考链接： 赛马娘 第二季

《无职转生》

《无职转生》是异世界题材集大成者，34 岁废人转生后弥补遗憾，细腻世界观和真实角色塑造令人印象深刻。
观看建议：适合深度异世界爱好者，忽略前期争议。
参考链接： 无职转生

《86-不存在的战区-》

《86》以机甲战争为外衣，探讨种族歧视与人性救赎，“86”与雷娜羁绊感人，泽野弘之配乐催泪神器。
观看建议：适合深刻剧情爱好者，准备被震撼。
参考链接： 86-不存在的战区-

2022 年

《更衣人偶坠入爱河》

《更衣人偶坠入爱河》讲述热爱 cosplay 的喜多川海梦与内向五条新菜因共同爱好擦出火花，对 cosplay 文化尊重令人感动，甜度爆表。
观看建议：适合浪漫与青春爱好者，准备被甜到。
参考链接： 更衣人偶坠入爱河

《间谍过家家》

《间谍过家家》是现象级合家欢作品，洛伊德、约尔和阿尼亚组成临时家庭，融合紧张与搞笑，温暖治愈。
观看建议：适合全年龄观众，享受欢乐与感动。
参考链接： 间谍过家家

《夏日重现》

《夏日重现》是高能悬疑片，慎平因青梅竹马葬礼卷入时间循环与影子传说，节奏快，反转多，智斗精彩。
观看建议：适合悬疑与智斗爱好者，一口气看完最爽。
参考链接： 夏日重现

《异世界舅舅》

2022 年的《异世界舅舅》是反套路异世界喜剧，主角是穿越者外甥，舅舅带魔法和 90 年代宅文化归来，回忆真实冒险，笑点密集，吐槽精准。
观看建议：适合搞笑和吐槽文化爱好者，准备笑到捶地。
参考链接： 异世界舅舅

《孤独摇滚！》

2022 年的《孤独摇滚！》（Bocchi the Rock!）是年度黑马，讲述社恐吉他天才少女后藤一里渴望组建乐队。天马行空演出展现社恐内心，爆笑中感同身受，音乐动听，制作精良。
观看建议：适合社恐人士和音乐爱好者，享受视听盛宴。
参考链接： 孤独摇滚！

2023 年

《别当欧尼酱了！》

2023 年的《别当欧尼酱了！》（Onimai: I’m Now Your Sister!）由动画工坊制作，将“萌”发挥极致。技术宅哥哥被妹妹药物变可爱女孩，顶级丝滑作画，细节丰富，表情生动，被誉为“作画厨天堂”。
观看建议：适合可爱画风和轻松喜剧爱好者，享受视觉盛宴。
参考链接： 别当欧尼酱了！

《我心里危险的东西》

2023 年的《我心里危险的东西》是出人意料纯爱故事，中二少年市川京太郎幻想“干掉”美少女山田杏奈，逐渐揭示暗恋，细腻描绘青春期敏感与纠结，后期甜度爆表。
观看建议：适合校园恋爱和情感细腻爱好者，准备被甜到。
参考链接： 我心里危险的东西

《【我推的孩子】》

2023 年的《【我推的孩子】》（Oshi no Ko）以 90 分钟超长首集开场，融合偶像、转生、悬疑与复仇，揭示娱乐圈黑暗面，节奏紧凑，话题性强，引发广泛讨论。
观看建议：适合悬疑与社会议题爱好者，准备被震撼。
参考链接： 【我推的孩子】

《BanG Dream! It’s MyGO!!!!!》

2023 年的《BanG Dream! It’s MyGO!!!!!》是能让你看偶像番看出胃疼的“奇药”。它抛弃阳光套路，描绘五个性格沉重的少女如何因误会、逃避、嫉妒而分崩离析，又因无法割舍的感情重新走到一起。剧情扭曲，台词经典，人物关系剪不断理还乱，看得人又爱又恨。
观看建议：中文名《迷途羔羊》，适合扭曲情感爱好者，准备迎接下一部“母鸡卡”的洗礼。
参考链接： BanG Dream! It’s MyGO!!!!!

《葬送的芙莉莲》

《葬送的芙莉莲》像诗和散文般的治愈系奇幻番。活了上千年的精灵魔法使芙莉莲，在勇者同伴逝去后，才踏上了解人类的旅途。她沿着旧日足迹回忆点滴，在平淡中感受时光流逝与情感重量，不刻意煽情却能让人潸然泪下。
观看建议：适合静心欣赏，感受生命短暂而耀眼。
参考链接： 葬送的芙莉莲

2024 年

《迷宫饭》

《迷宫饭》将硬核奇幻 RPG 与严谨美食烹饪结合，主角莱欧斯小队为省钱救妹妹，走上以魔物为食的道路。史莱姆、蛇尾鸡、宝箱怪皆可食，设定离谱但看得人口水直流，构建了真实可信的奇幻世界。
观看建议：深夜慎看，以免饿到啃枕头。
参考链接： 迷宫饭

《败犬女主太多了！》

《败犬女主太多了！》标题即核心，当故事里全是恋爱喜剧中的败犬女主角时会发生什么？路人男主温水和彦与败犬们产生交集，充满自嘲和解构精神，疯狂吐槽恋爱番套路。
观看建议：适合看腻传统党争的观众，准备会心一笑。
参考链接： 败犬女主太多了！

《胆大党》

《胆大党》是混沌高速神经病佳作。信奉幽灵的少女与信奉外星人的宅男因赌约闯入彼此领域，开启被追着打的刺激冒险。想象力和画面表现力炸裂，剧情快到飞起，纯粹追求感官刺激。
观看建议：适合追求爽快与邪道剧情的观众。
参考链接： 胆大党

2025 年

《末日后酒店》

《银河楼福地》设定在人类离开后的废土地球，东京银座的“银河楼”酒店却持续营业，由机器人等待人类重返。设定新颖，在感人升华时突然转为喜剧，是一部值得期待的黑马。
观看建议：适合喜欢新颖设定和治愈喜剧的观众。
参考链接： 银河楼福地

结语

从 2003 年到 2025 年，这趟穿越了二十多年的动漫之旅暂时告一段落。我们一起见证了“等价交换”的沉重，感受了“轻音少女”的悠闲；我们为“石头门”的选择而揪心，也为“芙莉莲”的千年孤寂而感叹。

对于我们来说，动画早已不是简单的娱乐，它是一代人的青春，是另一个世界的梦想，是我们疲惫生活里的英雄梦。它教会我们羁绊、成长、爱与勇气。或许我们终将长大，但心中那份对二次元的热爱永远不会褪色，因为正是这些闪闪发光的故事，构成了我们人生中不可或缺的一部分。

感谢你的阅读，希望这份片单能为你带来美好的观影体验。如果你有特别喜欢的作品，也欢迎在评论中分享！

在数字时代，翻译工具不仅是语言沟通的桥梁，更是文化交流的纽带。沉浸式翻译（Immersive Translate）浏览器插件通过整合多种翻译接口，让用户在浏览网页或阅读文档时轻松获取双语内容。然而，不同翻译接口的质量差异可能显著影响用户体验。本文通过 12 个测试用例，深入比较微软翻译、谷歌翻译、硅基流动和 DeepLX 自建 API 在技术、文学、商务、文化和对话场景中的表现，旨在找出最佳翻译接口。

背景介绍

沉浸式翻译是一款广受欢迎的浏览器扩展，支持网页、PDF 和字幕的实时双语翻译。它通过智能识别网页主要内容区域，提供逐段翻译，保留原文布局，极大提升阅读体验（Immersive Translate 官网）。该插件支持多种翻译引擎，包括微软翻译、谷歌翻译、硅基流动和 DeepLX 自建 API。以下是各接口简介：

• 微软翻译：微软提供的翻译服务，集成于其产品生态，覆盖多种语言，但在文学和习语翻译上可能稍逊。
• 谷歌翻译：全球最广泛使用的翻译工具，凭借神经机器翻译技术，支持 130+种语言，适合通用场景（Google Translate）。
• 硅基流动：一家专注于 AI 基础设施的中国公司，提供包括 Qwen2 和 GLM-4 在内的开源模型 API，免费且高效，适合技术性翻译（SiliconFlow 官网）。
• DeepLX 自建 API：可能是基于 DeepL 技术的自定义 API，以高精度和语境准确性著称，尤其在欧洲语言和中文翻译中表现优异（DeepL 官网）。

我们将通过五大类测试用例，评估这些接口在准确性、流畅性、语气保持和特殊术语处理方面的表现。

测试方法

我们设计了 12 个测试用例，涵盖以下类别：

1. 技术与科学文本：测试术语准确性和逻辑清晰度。
2. 文学与描述文本：评估语言的美感和意象保留。
3. 商务与正式沟通：检查正式语气和专业术语的翻译。
4. 文化与习语表达：分析习语和文化概念的处理。
5. 对话与营销文本：关注日常用语的自然性和营销语言的吸引力。

每个用例提供原始英文文本和四种接口的中文翻译，评估标准包括：

• 准确性：翻译是否准确传达原文意思。
• 流畅性：翻译是否自然，符合中文表达习惯。
• 语气与风格：是否保留原文的语气（如正式、诗意）。
• 特殊用例处理：对习语、文化术语或歧义句的处理能力。

测试用例与分析

1. 技术与科学文本

测试用例 1：CRISPR-Cas9 系统

原文：
“The CRISPR-Cas9 system enables precise genome editing by utilizing a guide RNA to target specific DNA sequences. This revolutionary technology, albeit controversial, holds promise for treating genetic disorders.”

翻译：

• 微软翻译：CRISPR-Cas9 系统利用向导 RNA 靶向特定 DNA 序列，从而实现精确的基因组编辑。这项革命性的技术尽管存在争议，但有望治疗遗传疾病。
• 谷歌翻译：CRISPR-Cas9 系统利用向导 RNA 靶向特定 DNA 序列，实现精准的基因组编辑。这项革命性的技术虽然存在争议，但在治疗遗传疾病方面却前景光明。
• 硅基流动：CRISPR-Cas9 系统通过利用向导 RNA 靶向特定 DNA 序列，实现精准的基因编辑。尽管这项革命性技术存在争议，但它有望用于治疗遗传性疾病。
• DeepLX：CRISPR-Cas9 系统利用引导 RNA 靶向特定 DNA 序列，实现精确的基因组编辑。这项革命性的技术虽然饱受争议，但却为治疗遗传疾病带来了希望。

参考译文

CRISPR-Cas9 基因编辑系统通过向导 RNA 靶向特定 DNA 序列，实现精准基因组编辑。这项突破性技术虽存争议，但为治疗遗传性疾病带来希望。

评估：
科学领域中，“guide RNA”标准译名为“引导 RNA”，DeepLX 正确使用此术语，而微软翻译、谷歌翻译、硅基流动使用“向导 RNA”，不够准确。硅基流动将“genome editing”译为“基因编辑”，而非更精确的“基因组编辑”。DeepLX 的翻译准确且流畅，是最佳选择。

最佳：DeepLX

测试用例 2：量子纠缠

原文：
“Quantum entanglement demonstrates non-local correlations exceeding classical Bell inequalities.”

翻译：

• 微软翻译：量子纠缠证明了超过经典贝尔不等式的非局部相关性。
• 谷歌翻译：量子纠缠表现出超越经典贝尔不等式的非局部相关性。
• 硅基流动：量子纠缠展示了超越经典贝尔不等式的非局域相关性。
• DeepLX：量子纠缠显示了超越经典贝尔不等式的非局部相关性。

参考译文

量子纠缠现象展现出超越经典贝尔不等式的非局域关联性。

评估：
物理学中，“非局域”是标准术语，硅基流动正确使用，而微软翻译、谷歌翻译、DeepLX 使用“非局部”。“demonstrates”更适合译为“展示”，硅基流动的“展示了”优于微软翻译的“证明了”。硅基流动在术语和语义上最准确。

最佳：硅基流动

测试用例 3：智能手机规格

原文：
“The new HyperEdge X2000 smartphone features a 7.2-inch AMOLED display, octa-core processor clocked at 3.1 GHz, 12 GB of LPDDR5 RAM, and a 5,000 mAh battery with 65 W fast charging. Its neural processing unit (NPU) accelerates on-device AI tasks such as real-time language translation and image recognition.”

翻译：

• 微软翻译：新款 HyperEdge X2000 智能手机配备 7.2 英寸 AMOLED 显示屏、主频为 3.1 GHz 的八核处理器、12 GB LPDDR5 RAM 和 5,000 mAh 电池，可进行 65 W 快速充电。其神经处理单元（NPU）可加速设备上的 AI 任务，例如实时语言翻译和图像识别。
• 谷歌翻译：新款 HyperEdge X2000 智能手机配备 7.2 英寸 AMOLED 显示屏、3.1 GHz 八核处理器、12 GB LPDDR5 RAM 以及支持 65 W 快速充电的 5,000 mAh 电池。其神经处理单元 (NPU) 可加速设备上的 AI 任务，例如实时语言翻译和图像识别。
• 硅基流动：新发布的 HyperEdge X2000 智能手机配备了一块 7.2 英寸的 AMOLED 显示屏，八核处理器主频为 3.1 GHz，12 GB 的 LPDDR5 内存，以及 5000mAh 电池和 65W 快充。其神经处理单元（NPU）可加速设备上的 AI 任务，如实时语言翻译和图像识别。
• DeepLX：新发布的 HyperEdge X2000 智能手机配备了一块 7.2 英寸的 AMOLED 显示屏，八核处理器主频为 3.1 GHz，12 GB 的 LPDDR5 内存，以及 5000mAh 电池和 65W 快充。其神经处理单元（NPU）可加速设备上的 AI 任务，如实时语言翻译和图像识别。

参考译文

新款 HyperEdge X2000 智能手机配备 7.2 英寸 AMOLED 显示屏、3.1 GHz 八核处理器、12 GB LPDDR5 内存以及 5000 mAh 电池，支持 65 W 快充。其神经处理单元（NPU）可加速实时语言翻译、图像识别等设备端 AI 任务。

评估：
微软翻译的“可进行 65 W 快速充电”措辞生硬，硅基流动和 DeepLX 使用“65W 快充”更简洁自然。硅基流动和 DeepLX 将“RAM”译为“内存”，符合中文习惯。两者在清晰度和准确性上并列最佳。

最佳：硅基流动，DeepLX

2. 文学与描述文本

测试用例 1：日落描述

原文：
“The amber sunset bled across the horizon, casting long shadows that danced upon the cobblestone streets. A whisper of wind carried the scent of petrichor – that earthy fragrance after rain.”

翻译：

• 微软翻译：琥珀色的夕阳在地平线上流血，投下长长的影子，在鹅卵石街道上跳舞。一阵风吹拂着 petrichor 的香味——雨后泥土的香味。
• 谷歌翻译：琥珀色的夕阳洒落在地平线上，长长的影子在鹅卵石街道上舞动。微风轻拂，带来雨后泥土的芬芳——那是泥土的清香。
• 硅基流动：夕阳的琥珀色余晖蔓延至地平线，长长的影子在鹅卵石街道上跳跃起舞。微风中带着雨后泥土的芬芳——那特有的大地香气。
• DeepLX：琥珀色的夕阳划过地平线，投下长长的影子，在鹅卵石街道上飞舞。一阵风拂过，带着雨后泥土的芬芳。

参考译文

琥珀色暮霭浸染天际，在鹅卵石街道上投下摇曳的长影。微风轻拂，带来雨后泥土的芬芳——那便是”petrichor”（雨久土香）。

评估：
微软翻译的“流血”虽保留“bled”的意象，但过于直白。谷歌翻译的“洒落”较为平淡，硅基流动的“蔓延”更贴合“bled across”的意境，且“特有的大地香气”对“petrichor”的翻译富有诗意。硅基流动在文学性上最佳。

最佳：硅基流动

测试用例 2：黎明描述

原文：
“At dawn, the mist hung low over the rolling hills, each blade of grass shimmering with dewdrops like a field of diamonds. A solitary lark broke the silence, its song cascading through the valley, heralding the promise of a new day.”

翻译：

• 微软翻译：黎明时分，薄雾低低地笼罩着连绵起伏的山丘，每一片草叶上都闪耀着露珠，就像一片钻石田。一只孤独的百灵鸟打破了寂静，它的歌声在山谷中倾泻而下，预示着新的一天的到来。
• 谷歌翻译：黎明时分，薄雾低垂，笼罩着连绵起伏的山峦，每一片草叶都闪耀着露珠的光芒，宛如一片璀璨的钻石田。一只孤独的云雀打破了寂静，它的歌声回荡在山谷间，宣告着新一天的到来。
• 硅基流动：黎明时分，薄雾低垂在起伏的山丘上，每片草叶上都闪烁着露珠，犹如一片钻石的田野。一只孤独的云雀打破了寂静，它的歌声回荡在山谷中，预示着新一天的希望。
• DeepLX：黎明时分，薄雾低垂，笼罩着连绵起伏的群山，每一片草叶上都闪烁着露珠，宛如一地钻石。一只孤独的百灵鸟打破了寂静，它的歌声在山谷中回荡，预示着新一天的到来。

参考译文

拂晓时分，薄雾低垂于起伏的山丘，草叶上的露珠闪烁如一片钻石田野。一只孤独的云雀打破了寂静，它的歌声在山谷中回旋，为新一天带来希望的序曲。

评估：
“Lark”应译为“云雀”，谷歌翻译和硅基流动正确，而微软翻译和 DeepLX 使用“百灵鸟”不够准确。谷歌翻译的“歌声回荡在山谷间”比微软翻译的“倾泻而下”更自然，且“山峦”与“山丘”同义。谷歌翻译在准确性和诗意上最佳。

最佳：谷歌翻译（谷歌翻译）

3. 商务与正式沟通

测试用例 1：财务报告邮件

原文：
“Per our teleconference, please find attached the Q3 financial report for your review. We recommend a phased implementation strategy to mitigate potential operational disruptions.”

翻译：

• 微软翻译：根据我们的电话会议，请找到随附的第 3 季度财务报告供您查看。我们建议分阶段实施策略，以减少潜在的运营中断。
• 谷歌翻译：根据我们的电话会议安排，附件中的第三季度财务报告供您查阅。我们建议采取分阶段实施策略，以减少潜在的运营中断。
• 硅基流动：根据我们电话会议的内容，请查收附件中的第三季度财务报告供您审阅。我们建议采取分阶段实施的策略以减轻潜在的运营中断风险。
• DeepLX：根据我们的电话会议，随函附上第三季度财务报告，供您审阅。我们建议采取分阶段实施战略，以减少潜在的运营中断。

参考译文

根据电话会议讨论，随函附上第三季度财报供您审阅。建议采用分阶段实施策略，以降低运营中断风险。

评估：
微软翻译的“请找到”不正确，应为“请见附件”。硅基流动添加“风险”一词，原文无此含义，降低准确性。DeepLX 使用“随函附上”和“战略”，语气正式且准确，是最佳选择。

最佳：DeepLX

4. 文化与习语表达

测试用例 1：“Break a leg!”与“小康社会”

原文：
““Break a leg!” she called out, a quintessential Western idiom that baffled non-native speakers. Meanwhile, the Chinese concept of “小康社会” (xiǎokāng shèhuì) embodies social harmony.”

翻译：

• 微软翻译：她喊道：“打断一条腿！”，这是典型的西方成语，让非母语人士感到困惑。同时，中国的“小康社会”（xiǎokāng shèhuì）概念体现了社会和谐。
• 谷歌翻译：她喊道：“Break a leg！”这句典型的西方习语让非英语母语人士感到困惑。而中文里“小康社会”的概念则体现了社会和谐。
• 硅基流动：她喊道：“祝你好运！”这是一个典型的西方惯用语，让非母语者感到困惑。与此同时，“小康社会”（xiǎokāng shèhuì）这一概念则体现了社会和谐。
• DeepLX：”打断一条腿！”她喊道，这个典型的西方成语让非母语人士感到困惑。与此同时，中国的 “小康社会”（xiǎokāng shèhuì）概念体现了社会和谐。

参考译文

“Break a leg!”（祝好运！）她喊道——这个典型的西方习语常令非母语者困惑。而中国”小康社会”的理念则体现了社会和谐。

评估：
硅基流动将“Break a leg!”译为“祝你好运”，虽传达意思但丢失习语形式。微软翻译和 D 直译“打断一条腿”，可能让中文读者困惑。谷歌翻译保留英文原句，结合上下文解释，清晰且忠于原文意图。

最佳：谷歌翻译

测试用例 2：习语与谚语

原文：
“He’s a wolf in sheep’s clothing; still waters run deep.”

翻译：

• 微软翻译：他是一只披着羊皮的狼;大智若愚。
• 谷歌翻译：他是披着羊皮的狼；静水流深。
• 硅基流动：他貌狼心羊；静水深流。
• DeepLX：他是披着羊皮的狼；静水流深。

参考译文

他是个披着羊皮的狼；静水流深（表面平静却深藏不露）。

评估：
硅基流动的“貌狼心羊”错误，应为“披着羊皮的狼”。微软翻译的“大智若愚”与“still waters run deep”不符。谷歌翻译和 D 正确翻译两个习语为“披着羊皮的狼”和“静水流深”，并列最佳。

最佳：谷歌翻译，DeepLX

测试用例 3：日常对话中的习语

原文：
““Could you pass the salt? Oh, never mind – I spilled the beans already!””

翻译：

• 微软翻译：“你能把盐传出去吗？哦，没关系——我已经把豆子洒了！
• 谷歌翻译：“你能把盐递过来吗？哦，没关系——我已经说漏嘴了！”
• 硅基流动：“能把盐递给我吗？哦，算了——我已经不小心说漏嘴了！”
• DeepLX：”能把盐递给我吗？哦，算了–我已经说漏嘴了！”

参考译文

“能递下盐吗？哦不用了——我刚刚说漏嘴了！” （注：”spilled the beans”译为”说漏嘴”而非直译”打翻豆子”）

评估：
微软翻译将“spilled the beans”直译为“把豆子洒了”，错误。谷歌翻译、硅基流动、DeepLX 正确使用“说漏嘴了”。微软翻译的“传出去”不自然，谷歌翻译和 DeepLX 更简洁，硅基流动的“不小心”虽可接受但非必要。谷歌翻译和 DeepLX 并列最佳。

最佳：谷歌翻译，DeepLX

5. 对话与营销文本

测试用例 1：歧义句

原文：
“The man saw the woman with binoculars.”

翻译：

• 微软翻译：男人用双筒望远镜看到了那个女人。
• 谷歌翻译：男人用望远镜看见了那个女人。
• 硅基流动：那人用望远镜看到了那个女人。
• DeepLX：男人用望远镜看到了那个女人。

参考译文

男子看见了那位拿着望远镜的女子。/ 男子用望远镜看见了那位女子。（需保留双重含义）

评估：
原文有歧义（可能是“用望远镜看”或“看到带望远镜的女人”），但所有翻译都解为“用望远镜看”，丢失歧义。硅基流动用“那人”不如微软翻译、谷歌翻译、DeepLX 的“男人”具体。谷歌翻译简洁且使用标准术语“望远镜”。

最佳：无

测试用例 2：体育比赛对话

原文：
“Alice: “Hey, Tom! Did you catch the game last night? It was epic—overtime, last-second three-pointer, the whole nine yards!” Tom: “Absolutely! I couldn’t believe how the crowd went wild. Truly a nail-biter.””

翻译：

• 微软翻译：爱丽丝：“嘿，汤姆！你昨晚看比赛了吗？那真是史诗般的——加时赛，最后一秒的三分球，整整九码！ 汤姆：“当然！我简直不敢相信人群是怎么疯狂的。真是个令人毛骨悚然的人。”
• 谷歌翻译：爱丽丝：“嘿，汤姆！你昨晚看比赛了吗？真是精彩绝伦——加时赛，最后一秒的三分球，精彩绝伦！” 汤姆：“绝对精彩！我简直不敢相信观众竟然如此疯狂。真是扣人心弦。”
• 硅基流动：Alice: “嘿，汤姆！你昨晚看了比赛吗？太精彩了——加时赛，最后一秒的三分球，一切都有了！” Tom: “当然！我简直不敢相信现场观众的热情。真是悬念重重。”
• DeepLX：爱丽丝:”嘿，汤姆！你看了昨晚的比赛吗？太精彩了，加时赛，最后一秒三分球，太精彩了！” 汤姆:”当然！我简直不敢相信观众是多么疯狂。真是扣人心弦啊！”

参考译文

爱丽丝（Alice）：“嗨，汤姆！你昨晚看比赛了吗？简直太精彩了——加时赛、压哨三分，真是一应俱全！”
汤姆（Tom）：“当然看了！观众们的狂热让我难以置信，真是扣人心弦。”

评估：
微软翻译将“the whole nine yards”直译为“整整九码”，错误，且“nail-biter”译为“令人毛骨悚然的人”不正确。硅基流动将“the whole nine yards”译为“一切都有了”，较好地传达意思，且“nail-biter”译为“悬念重重”准确。硅基流动在习语和语气上最佳。

最佳：硅基流动

测试用例 3：营销文案（ZenFocus）

原文：
“Unlock your potential with “ZenFocus”—the productivity app that adapts to your workflow. From smart reminders to distraction-blocking modes, ZenFocus helps you achieve more in less time. Sign up today and get a 14-day free trial!”

翻译：

• 微软翻译：使用“ZenFocus”释放您的潜力 - 适应您的工作流程的生产力应用程序。从智能提醒到分散注意力的模式，ZenFocus 可帮助您在更短的时间内实现更多目标。立即注册并获得 14 天免费试用！
• 谷歌翻译：使用“ZenFocus”——一款适应您工作流程的生产力应用，释放您的潜能。从智能提醒到干扰屏蔽模式，ZenFocus 助您事半功倍。立即注册，即可享受 14 天免费试用！
• 硅基流动：使用“ZenFocus”解锁你的潜力——这款适应你工作流程的生产力应用。从智能提醒到防干扰模式，ZenFocus 帮助你在更短的时间内完成更多任务。今天注册，享受 14 天免费试用期！
• DeepLX：用 “ZenFocus “释放你的潜能–一款能适应你的工作流程的生产力应用程序。从智能提醒到分心阻断模式，ZenFocus 帮助你在更短的时间内实现更多目标。立即注册，获得 14 天免费试用！

参考译文

解锁你的潜能，用“ZenFocus”——一款能适应你工作流程的效率应用。从智能提醒到阻断干扰模式，ZenFocus 助你用更少的时间完成更多任务。立即注册，享受 14 天免费试用！

评估：
微软翻译将“distraction-blocking modes”误译为“分散注意力的模式”，意思相反。B 使用“干扰屏蔽模式”正确，且“事半功倍”是一个吸引人的成语，增强营销效果。B 在准确性和吸引力上最佳。

最佳：谷歌翻译

结果总结

以下是各测试用例最佳接口的汇总表：

为确定总体最佳接口，我们为独占最佳分配 1 分，共享最佳分配 0.5 分：

• 谷歌翻译：独占最佳（4、5、黎明描述、营销文案）4 分，共享最佳（习语与谚语、日常对话）1 分，总计 5 分。
• 硅基流动：独占最佳（量子纠缠、日落描述、体育比赛对话）3 分，共享最佳（智能手机规格）0.5 分，总计 3.5 分。
• DeepLX：独占最佳（CRISPR-Cas9、财务报告）2 分，共享最佳（智能手机规格、习语与谚语、日常对话）1.5 分，总计 3.5 分。
• 微软翻译：无最佳，0 分。

结论与推荐

谷歌翻译以 5 分的总分成为最均衡的翻译接口，适合通用翻译需求，尤其在文化习语、歧义句和营销文案中表现出色。其神经机器翻译技术支持 130+种语言，广泛适用于网页浏览和日常使用（Google Translate）。

DeepLX 在技术性和商务文本中表现突出，可能是由于其基于 DeepL 的技术，DeepL 以高精度和语境准确性著称（DeepL 官网）。对于需要专业术语的场景，如学术论文或正式文档，DeepLX 是优选。

硅基流动在科学术语和文学描述方面表现优异，可能得益于其使用 Qwen2 或 GLM-4 等先进模型（SiliconFlow 官网）。对于科学或艺术性文本，硅基流动是不错的选择。

微软翻译在测试中表现较弱，尤其在习语和文学翻译中，可能是由于其在语境处理上的局限性。

推荐：

• 通用需求：选择谷歌翻译以获得均衡表现。
• 技术与商务：优先考虑 DeepLX 以确保高精度。
• 科学与文学：硅基流动适合专业或艺术性翻译。

沉浸式翻译插件的灵活性允许用户根据具体需求切换接口，最大化翻译效果。未来，随着 AI 模型的进步，硅基流动和 DeepLX 可能进一步挑战谷歌翻译的霸主地位。

在进一步深入学习 C++的过程中，我们探索了面向对象编程的思想，并掌握了类和对象的核心概念。我们了解了如何使用封装来保护数据、对象的初始化和清理机制、C++对象模型和this指针的作用。此外，我们还学习了友元、运算符重载、继承、多态以及文件操作。这些知识点将帮助我们构建更复杂的系统，提升编程的结构化和模块化。

为了实践这些新知识，本项目将基于多态性来实现一个常见的期末大作业项目——职工管理系统。这个管理系统可以帮助公司管理所有员工的信息，记录职工的基本情况并简化人事操作流程。

在本教程中，我们将利用 C++的面向对象特性来设计和实现一个多态的职工管理系统。系统中，公司职工分为三类：普通员工、经理和老板，每类职工的职责各不相同，具体如下：

• 普通员工职责：完成经理分配的任务。
• 经理职责：执行老板布置的任务，同时将任务下发给普通员工。
• 老板职责：管理公司所有事务，确保公司正常运作。

在此管理系统中，我们需要实现以下核心功能：

• 增加职工信息：实现批量添加职工功能，将每个职工的编号、姓名和部门编号记录到文件中。
• 显示职工信息：展示公司所有职工的基本信息。
• 删除离职职工：根据职工编号删除指定的职工记录。
• 修改职工信息：根据编号修改职工的个人信息。
• 查找职工信息：支持根据职工编号或姓名进行查询，快速定位相关人员信息。
• 按照编号排序：对职工按照编号进行排序，用户可选择不同的排序规则。
• 清空所有文档：清空文件中记录的职工信息，删除前需确认，以防误删。
• 退出管理程序：结束当前的管理系统，退出程序。

系统的界面效果图如下所示：

用户可以通过不同的选项来操作系统，执行相应的功能。

1、创建管理类

在本项目中，我们将采用分文件的结构来构建整个职工管理系统，这种方式比将所有代码放在单一 .cpp 文件中更有优势。分文件法便于代码维护，每个文件专注于不同的功能模块，使项目结构更清晰、逻辑更分明。

管理类负责的内容如下：

• 展示菜单界面，与用户进行交互
• 实现对职工的增、删、改、查操作
• 处理文件的读写，保存和加载职工信息

首先，我们在项目中创建两个文件夹：一个用于存放头文件，另一个用于存放源文件。在头文件目录中，创建workerManager.h，在源文件目录中创建workerManager.cpp，分别定义和实现管理类。

以下是workerManager.h中管理类的初始定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#pragma once
#include<iostream>
using namespace std;


class WorkerManager
{
public:

//构造函数
WorkerManager();

//析构函数
~WorkerManager();

};

此处，WorkerManager类包含构造函数和析构函数的声明，用于初始化和清理管理类的实例。

源文件实现:

在workerManager.cpp中，我们为构造函数和析构函数提供空实现，以便为后续功能扩展提供基础。

1
2
3
4
5
6
7
8
9
10

#include "workerManager.h"

WorkerManager::WorkerManager()
{
}

WorkerManager::~WorkerManager()
{
}

至此，职工管理类的基本结构已完成。

2、菜单功能

功能描述：与用户的沟通界面，如图所示：

2.1 添加成员函数

在管理类 workerManager.h 中添加成员函数 void Show_Menu();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void WorkerManager::Show_Menu()
{
cout << "********************************************" << endl;
cout << "*********  欢迎使用职工管理系统！ **********" << endl;
cout << "*************  0.退出管理程序  *************" << endl;
cout << "*************  1.增加职工信息  *************" << endl;
cout << "*************  2.显示职工信息  *************" << endl;
cout << "*************  3.删除离职职工  *************" << endl;
cout << "*************  4.修改职工信息  *************" << endl;
cout << "*************  5.查找职工信息  *************" << endl;
cout << "*************  6.按照编号排序  *************" << endl;
cout << "*************  7.清空所有文档  *************" << endl;
cout << "********************************************" << endl;
cout << endl;
}

3、创建职工类

在职工管理系统中，职工分为三类：普通员工、经理和老板。我们将这三种类型的职工抽象成一个基类（Worker），并通过多态来管理不同类型的职工。每种职工类型将拥有各自的岗位职责和工作描述，从而实现灵活的扩展性和可维护性。

3.1 创建职工抽象类

职工的分类为：普通员工、经理、老板

将三种职工抽象到一个类（worker）中,利用多态管理不同职工种类

职工的属性为：职工编号、职工姓名、职工所在部门编号

职工的行为为：岗位职责信息描述，获取岗位名称

我们将Worker类作为抽象基类，定义职工的基本属性和行为：

• 属性：职工编号、职工姓名、职工所在部门编号
• 行为：显示个人信息、获取岗位名称（纯虚函数）

在头文件文件夹下创建worker.h文件，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// worker.h
#pragma once
#include <iostream>
#include <string>
using namespace std;

// 职工抽象基类
class Worker
{
public:
    // 显示个人信息
    virtual void showInfo() = 0;

    // 获取岗位名称
    virtual string getDeptName() = 0;

    int m_Id;       // 职工编号
    string m_Name;  // 职工姓名
    int m_DeptId;   // 职工所在部门编号
};

该基类的纯虚函数showInfo和getDeptName要求子类必须实现具体的行为描述和岗位名称获取功能。

3.2 创建普通员工类

普通员工类继承自Worker抽象类，并实现父类中的纯虚函数。普通员工的职责是完成经理分配的任务。

在头文件和源文件文件夹下分别创建employee.h和employee.cpp文件。

employee.h 中代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// employee.h
#pragma once
#include <iostream>
#include <string>
#include "worker.h"

class Employee : public Worker
{
public:
    Employee(int id, string name, int dId);

    // 显示个人信息
    virtual void showInfo();

    // 获取岗位名称
    virtual string getDeptName();
};

employee.cpp代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// employee.cpp
#include "employee.h"
#include <iostream>
#include <string>
using namespace std;

Employee::Employee(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

// 显示个人信息
void Employee::showInfo()
{
    cout << "姓名：" << this->m_Name
         << "\t职工编号：" << this->m_Id
         << "\t岗位：" << this->getDeptName()
         << "\t\t职责：完成经理的任务" << endl;
}

// 获取岗位名称
string Employee::getDeptName()
{
    return string("员工");
}

3.3 创建经理类

经理类继承自Worker抽象类，并实现父类中的纯虚函数。经理的职责是执行老板布置的任务，并将任务下发给普通员工。

在头文件和源文件文件夹下分别创建manager.h和manager.cpp文件。

manager.h代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// manager.h
#pragma once
#include <iostream>
#include <string>
#include "worker.h"

class Manager : public Worker
{
public:
    Manager(int id, string name, int dId);

    // 显示个人信息
    virtual void showInfo();

    // 获取岗位名称
    virtual string getDeptName();
};

manager.cpp代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// manager.cpp
#include "manager.h"
#include <iostream>
#include <string>
using namespace std;

Manager::Manager(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

// 显示个人信息
void Manager::showInfo()
{
    cout << "姓名：" << this->m_Name
         << "\t职工编号：" << this->m_Id
         << "\t岗位：" << this->getDeptName()
         << "\t\t职责：完成老板的任务并下发给员工" << endl;
}

// 获取岗位名称
string Manager::getDeptName()
{
    return string("经理");
}

3.4 创建老板类

老板类继承自Worker抽象类，并实现父类中的纯虚函数。老板的职责是管理公司所有事务，确保公司运作顺利。

在头文件和源文件文件夹下分别创建boss.h和boss.cpp文件。

boss.h代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// boss.h
#pragma once
#include <iostream>
#include <string>
#include "worker.h"

class Boss : public Worker
{
public:
    Boss(int id, string name, int dId);

    // 显示个人信息
    virtual void showInfo();

    // 获取岗位名称
    virtual string getDeptName();
};

boss.cpp代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// boss.cpp
#include "boss.h"
#include <iostream>
#include <string>
using namespace std;

Boss::Boss(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}

// 显示个人信息
void Boss::showInfo()
{
    cout << "姓名：" << this->m_Name
         << "\t职工编号：" << this->m_Id
         << "\t岗位：" << this->getDeptName()
         << "\t职责：管理公司的所有事务" << endl;
}

// 获取岗位名称
string Boss::getDeptName()
{
    return string("首席执行官");
}

至此，我们已经成功创建了包含普通员工、经理和老板的职工类体系，每个子类都继承了Worker抽象类，并实现了岗位职责的描述方法。这种基于多态的设计使得管理系统可以灵活扩展，方便添加新的职工类型或调整现有类型的职责。

3.5 测试多态

在职工管理系统.cpp中添加测试函数test()，用于验证职工管理系统中的多态功能是否能够正常运行。通过创建不同类型的职工对象（普通员工、经理和老板）并调用各自的showInfo()方法，我们可以观察到多态的效果。

测试代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include "worker.h"
#include "employee.h"
#include "manager.h"
#include "boss.h"

void test()
{
    Worker* worker = NULL;

    // 创建普通员工对象并展示信息
    worker = new Employee(1, "张员工", 1);
    worker->showInfo();
    delete worker;

    // 创建经理对象并展示信息
    worker = new Manager(2, "李经理", 2);
    worker->showInfo();
    delete worker;

    // 创建老板对象并展示信息
    worker = new Boss(3, "王老板", 3);
    worker->showInfo();
    delete worker;
}

在test()函数中，我们通过将Worker*指针指向不同类型的职工对象，并调用各自的showInfo()方法，实现了多态调用。每个对象根据其具体类型展示了不同的岗位职责描述，验证了多态的功能。

运行该测试函数后，终端或控制台应输出每个职工的详细信息，包括姓名、职工编号、岗位和职责描述。运行效果如下图所示：

测试成功后，您可以选择将test()函数的代码注释保留，方便日后测试或调试；或者选择删除该函数，以保持代码的简洁性。

4、添加职工

在本节中，我们实现一个批量添加职工的功能，并将新添加的职工数据保存到文件中。通过该功能，用户可以一次性添加多个职工，并将不同职工类别（普通员工、经理、老板）存储在统一的职工数组中。

4.1 功能分析

需求分析：

用户在批量创建职工时，可以选择不同类别的职工（普通员工、经理、老板）。为了方便管理和存储所有职工信息，我们将使用一个动态数组来存放职工对象的指针，动态扩展数组容量以适应新增数据。

技术实现：

为了实现动态管理不定长度的职工数组，我们将数组定义在堆区，并使用Worker**类型的指针来维护该数组，以便在需要时动态调整数组的大小。

4.2 功能实现

在 WorkerManager.h 中添加成员属性

在WorkerManager类中添加以下两个成员属性，用于记录当前职工人数和职工数组：

1
2
3
4
5
6

// 记录文件中的职工人数
int m_EmpNum;

// 职工数组指针，用于存放所有职工的指针
Worker** m_EmpArray;

初始化成员属性

在 WorkerManager 的构造函数中，初始化职工人数和职工数组指针：

1
2
3
4
5
6
7
8
9

WorkerManager::WorkerManager()
{
    // 初始化职工人数
    this->m_EmpNum = 0;

    // 初始化职工数组指针为空
    this->m_EmpArray = NULL;
}

添加职工函数声明

在WorkerManager.h头文件中声明Add_Emp()成员函数，用于添加职工：

1
2

// 增加职工
void Add_Emp();

实现 Add_Emp() 函数

在 workerManager.cpp 中实现 Add_Emp() 函数，具体步骤如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

void WorkerManager::Add_Emp()
{
    cout << "请输入需要增加的职工数量：" << endl;
    int addNum = 0;
    cin >> addNum;

    if (addNum > 0)
    {
        // 计算新增后的职工总数
        int newSize = m_EmpNum + addNum;

        // 创建一个新数组，大小为 newSize，用于存放新职工
        Worker** newSpace = new Worker*[newSize];

        // 将原有职工数组的数据拷贝到新数组中
        if (this->m_EmpArray != NULL)
        {
            for (int i = 0; i < this->m_EmpNum; i++)
            {
                newSpace[i] = this->m_EmpArray[i];
            }
        }

        // 开始添加新职工
        for (int i = 0; i < addNum; i++)
        {
            int id;
            string name;
            int dSelect;

            // 确保输入的职工编号唯一
            while (true)
            {
                cout << "请输入第" << i + 1 << "名新职工的编号：" << endl;
                cin >> id;
                int index = this->isExist(id);
                if (index == -1) break;
                else cout << "该职工编号已存在，请重新输入：" << endl;
            }

            cout << "请输入第" << i + 1 << "名新职工的姓名：" << endl;
            cin >> name;
            cout << "请选择第" << i + 1 << "名新职工的职工类型：" << endl;
            cout << "1、普通职工" << endl;
            cout << "2、经理" << endl;
            cout << "3、老板" << endl;
            cin >> dSelect;

            // 创建对应类型的职工对象并添加到数组中
            Worker* worker = NULL;
            switch (dSelect)
            {
            case 1:
                worker = new Employee(id, name, dSelect);
                break;
            case 2:
                worker = new Manager(id, name, dSelect);
                break;
            case 3:
                worker = new Boss(id, name, dSelect);
                break;
            default:
                cout << "无效的职工类型" << endl;
                break;
            }

            // 将新职工对象指针存入数组
            newSpace[this->m_EmpNum + i] = worker;
        }

        // 释放旧的职工数组内存
        delete[] this->m_EmpArray;

        // 更新指针和人数
        this->m_EmpArray = newSpace;
        this->m_EmpNum = newSize;

        cout << "成功添加" << addNum << "名新职工" << endl;

        // 更新文件标志并保存新数据到文件
        this->m_FileEmpty = false;
        this->save();
    }
    else
    {
        cout << "输入非法，添加失败" << endl;
    }

    system("pause");
    system("cls");
}

在 WorkerManager 析构函数中释放内存

为了避免内存泄漏，我们在析构函数中释放m_EmpArray数组的内存：

1
2
3
4
5
6
7
8

WorkerManager::~WorkerManager()
{
    if (this->m_EmpArray != NULL)
    {
        delete[] this->m_EmpArray;
    }
}

4.3 测试添加职工功能

在主程序的菜单选项中，调用 Add_Emp() 函数，并根据用户输入展示添加职工的结果。运行程序后，终端将显示添加的职工信息，如下图所示：

至此，职工添加功能已完成，实现了批量添加不同类别的职工并将信息保存至文件。

5、文件交互 - 写文件

在实现职工信息添加后，为了确保数据的持久化，我们需要将数据写入文件中，并在程序启动时从文件中读取这些数据。文件交互的流程可以分为两个步骤：文件写入和文件读取。

5.1 文件写入

在职工管理系统中，当新职工添加完成后，数据会写入文件以实现持久化。写文件的功能如下：

5.1.1 文件路径设定

在workerManager.h文件中定义文件路径常量，并包含fstream头文件：

1
2

#include <fstream>
#define FILENAME "empFile.txt"

5.1.2 成员函数声明

在 WorkerManager 类中声明 save() 函数，用于将职工数据写入文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void WorkerManager::save()
{
    ofstream ofs;
    ofs.open(FILENAME, ios::out);

    for (int i = 0; i < this->m_EmpNum; i++)
    {
        ofs << this->m_EmpArray[i]->m_Id << " "
            << this->m_EmpArray[i]->m_Name << " "
            << this->m_EmpArray[i]->m_DeptId << endl;
    }

    ofs.close();
}

5.1.3 保存文件功能测试

在成功添加职工后，调用save()函数，将职工信息写入文件：

1
2

this->save();

测试程序：运行程序添加职工，验证生成的empFile.txt文件中是否记录了新职工的信息。

5.2 文件读取

在程序启动时，从文件中加载职工数据到内存中，便于进行后续操作。文件读取功能将包括文件状态判断、数据读取和内存初始化。

5.2.1 文件状态判断

文件状态分为以下三种情况：

1. 文件未创建：即文件不存在。
2. 文件存在但无数据：文件存在但内容为空。
3. 文件存在并包含数据：文件存在且包含职工数据。

在 workerManager.h 中添加标志属性 m_FileIsEmpty，用于判断文件是否为空：

1
2

//标志文件是否为空
bool m_FileIsEmpty;

在构造函数 WorkerManager::WorkerManager 中，根据文件状态初始化数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

WorkerManager::WorkerManager()
{
    ifstream ifs;
    ifs.open(FILENAME, ios::in);

    if (!ifs.is_open())
    {
        // 文件不存在
        cout << "文件不存在" << endl;
        this->m_EmpNum = 0;
        this->m_FileIsEmpty = true;
        this->m_EmpArray = NULL;
        ifs.close();
        return;
    }

    // 文件存在，但内容为空
    char ch;
    ifs >> ch;
    if (ifs.eof())
    {
        cout << "文件为空!" << endl;
        this->m_EmpNum = 0;
        this->m_FileIsEmpty = true;
        this->m_EmpArray = NULL;
        ifs.close();
        return;
    }

    this->m_FileIsEmpty = false;
}

在成功添加职工后，将文件标志更新为非空：

1
2

this->m_FileIsEmpty = false;

5.2.2 获取职工记录数

在文件读取前，需要获取文件中职工的数量以便初始化数组。定义get_EmpNum函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int WorkerManager::get_EmpNum()
{
    ifstream ifs(FILENAME, ios::in);
    int id, dId, num = 0;
    string name;

    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        num++;
    }
    ifs.close();

    return num;
}

在构造函数中调用此函数，获取职工数量并初始化数组：

1
2
3
4

int num = this->get_EmpNum();
this->m_EmpNum = num;
cout << "文件中职工数量为：" << num << endl;

5.2.2 获取职工记录数

在文件读取前，需要获取文件中职工的数量以便初始化数组。定义get_EmpNum函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int WorkerManager::get_EmpNum()
{
    ifstream ifs(FILENAME, ios::in);
    int id, dId, num = 0;
    string name;

    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        num++;
    }
    ifs.close();

    return num;
}

在构造函数中调用此函数，获取职工数量并初始化数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int num = this->get_EmpNum();
this->m_EmpNum = num;
cout << "调试代码：文件中职工数量为：" << num << endl;
this->m_EmpArry = new Worker * [num];
this->init_Emp();

for (int i = 0; i < num; i++)
{
cout << "调试代码:";
cout << "职工号：" << this->m_EmpArry[i]->m_Id
<< " 姓名：" << this->m_EmpArry[i]->m_Name
<< " 部门编号：" << this->m_EmpArry[i]->m_DeptId << endl;
}

手动添加一些职工数据，测试获取职工数量函数

5.2.3 初始化职工数组

在WorkerManager类中定义init_Emp()函数，根据文件中的数据初始化m_EmpArray数组：

1
2

//初始化员工
void init_Emp();

在 WorkerManager.cpp 中实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void WorkerManager::init_Emp()
{
    ifstream ifs(FILENAME, ios::in);
    int id, dId, index = 0;
    string name;

    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        Worker* worker = NULL;
        if (dId == 1)
        {
            worker = new Employee(id, name, dId);
        }
        else if (dId == 2)
        {
            worker = new Manager(id, name, dId);
        }
        else
        {
            worker = new Boss(id, name, dId);
        }

        this->m_EmpArray[index++] = worker;
    }
    ifs.close();
}

在构造函数中调用init_Emp()初始化数据：

//根据职工数创建数组this->m_EmpArray = new Worker *[this->m_EmpNum];//初始化职工init_Emp();//测试代码for (int i = 0; i < m_EmpNum; i++){    cout << "职工号： " << this->m_EmpArray[i]->m_Id        << " 职工姓名： " << this->m_EmpArray[i]->m_Name        << " 部门编号： " << this->m_EmpArray[i]->m_DeptId << endl;}

至此，实现了完整的文件交互功能，包括文件写入和文件读取。测试代码可注释或删除。

6、显示职工

功能描述：显示当前所有职工信息

6.1 显示职工函数声明

在 workerManager.h 中添加成员函数 void Show_Emp();，用于显示所有职工信息。

1
2

//显示职工
void Show_Emp();

6.2 显示职工函数实现

在 workerManager.cpp 中实现成员函数 void Show_Emp();，该函数负责根据文件内容判断是否为空，并显示所有职工的详细信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

void WorkerManager::Show_Emp()
{
// 判断文件是否为空
if (this->m_FileEmpty)
{
cout << "文件不存在或为空！" << endl;
}
else
{
// 文件非空，逐个显示职工信息
for (int i = 0; i < this->m_EmpNum; i++)
{
this->m_EmpArray[i]->showInfo();  // 调用职工的 showInfo() 方法显示信息
}
}
system("pause");  // 暂停屏幕显示
system("cls");    // 清空控制台
}

// 根据职工编号查询职工是否存在
int WorkerManager::isExist(int id)
{
int index = -1;
for (int i = 0; i < this->m_EmpNum; i++)
{
if (this->m_EmpArray[i]->m_Id == id)  // 如果职工编号匹配
{
index = i;  // 记录职工位置
break;
}
}
// 调试信息：返回职工的位置
// cout << "调试代码：index=" << index << endl;
return index;
}

// 删除职工
void WorkerManager::Del_Emp()
{
// 判断文件是否为空
if (this->m_FileIsEmpty)
{
cout << "文件不存在或为空，删除失败！" << endl;
}
else
{
cout << "请输入要删除的职工编号：" << endl;
int id;
cin >> id;

// 查找职工是否存在
int index = this->isExist(id);
if (index == -1)  // 职工不存在
{
cout << "职工不存在，删除失败！" << endl;
}
else
{
// 删除职工，移动数组元素
for (int i = index; i < this->m_EmpNum - 1; i++)
{
this->m_EmpArray[i] = this->m_EmpArray[i + 1];  // 将下一个职工信息前移
}
this->m_EmpNum--;  // 更新职工数量
this->save();      // 保存文件，确保删除后的数据被存储
cout << "删除成功！期待与ta的再次见面~" << endl;
}
}
system("pause");  // 暂停屏幕显示
system("cls");    // 清空控制台
}

6.3 测试显示职工

在 main 函数中的分支 2 选项中，调用 Show_Emp() 接口进行显示职工功能测试。测试时分别考虑文件为空和文件不为空两种情况。

测试 1 - 文件不存在或为空情况

测试效果：当文件为空或不存在时，程序会显示“文件不存在或为空”。

测试 2 - 文件存在且有记录情况

测试效果：当文件存在并且有职工记录时，程序将显示职工的详细信息。

至此，显示所有职工信息功能已完整实现。测试代码可以在调试完成后进行注释或删除。

7、删除职工

功能描述：按照职工的编号进行删除职工操作

7.1 删除职工函数声明

在 workerManager.h 中添加成员函数 void Del_Emp();，用于删除职工。

1
2

//删除职工
void Del_Emp();

7.2 职工是否存在函数声明

为了支持删除职工、修改职工、查找职工等功能，添加一个判断职工是否存在的函数，以便后续调用。

在 workerManager.h 中添加成员函数 int IsExist(int id);，用于判断职工是否存在。

1
2
3

// 按照职工编号判断职工是否存在, 若存在返回职工在数组中的位置，不存在返回-1
int IsExist(int id);

7.3 职工是否存在函数实现

在 workerManager.cpp 中实现成员函数 int IsExist(int id);，该函数负责判断职工是否存在。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int WorkerManager::isExist(int id)
{
int index = -1;  // 初始化为-1，表示未找到职工
for (int i = 0; i < this->m_EmpNum; i++)
{
// 如果职工编号匹配，则返回该职工在数组中的位置
if (this->m_EmpArray[i]->m_Id == id)
{
index = i;
break;
}
}
// 调试信息：返回职工的位置
// cout << "调试代码：index=" << index << endl;
return index;  // 若未找到，返回-1
}

7.4 删除职工函数实现

在 workerManager.cpp 中实现成员函数 void Del_Emp();，该函数实现删除职工操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

void WorkerManager::Del_Emp()
{
// 判断文件是否为空
if (this->m_FileIsEmpty)  // 注意：原文中为 m_FileEmpty，修改为 m_FileIsEmpty 更符合命名规范
{
cout << "文件不存在或为空，删除失败！" << endl;
}
else
{
cout << "请输入要删除的职工编号：" << endl;
int id;
cin >> id;

// 查找职工是否存在
int index = this->isExist(id);
if (index == -1)  // 职工不存在
{
cout << "职工不存在，删除失败！" << endl;
}
else
{
// 删除职工，移动数组元素
for (int i = index; i < this->m_EmpNum - 1; i++)
{
// 将下一个职工信息前移
this->m_EmpArray[i] = this->m_EmpArray[i + 1];
}
this->m_EmpNum--;  // 更新职工数量
this->save();      // 保存文件，确保删除后的数据被存储
cout << "删除成功！期待与ta的再次见面~" << endl;
}
}
system("pause");  // 暂停屏幕显示
system("cls");    // 清空控制台
}

7.5 测试删除职工

在 main 函数中的分支 3 选项中，调用 Del_Emp() 接口进行删除职工功能的测试。测试时分别考虑删除不存在职工和删除已存在职工两种情况。

测试 1 - 删除不存在职工情况

测试效果：当输入不存在的职工编号时，程序会输出“职工不存在，删除失败”提示。

测试 2 - 删除存在的职工情况

删除成功提示图：

测试效果：当输入存在的职工编号时，程序会成功删除该职工，并提示“删除成功！期待与 ta 的再次见面~”。

再次显示所有职工信息，确保已经删除

测试效果：删除职工后，调用显示职工信息接口，确认职工已被成功删除。

至此，删除职工功能已完整实现。测试代码可以在调试完成后进行注释或删除。

8、修改职工

功能描述：能够按照职工的编号对职工信息进行修改并保存。

8.1 修改职工函数声明

在 workerManager.h 中添加成员函数 void Mod_Emp();，用于修改职工信息。

1
2

//修改职工
void Mod_Emp();

8.2 修改职工函数实现

在 workerManager.cpp 中实现成员函数 void Mod_Emp();，该函数用于修改指定职工的个人信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

void WorkerManager::Mod_Emp()
{
// 判断文件是否为空
if (this->m_FileEmpty)
{
cout << "文件不存在或者为空，无法修改！" << endl;
return;  // 若文件为空，则退出函数
}

// 输入需要修改的职工编号
cout << "请输入需要修改的职工的编号：" << endl;
int id;
cin >> id;

// 查找职工是否存在
int index = this->isExist(id);
if (index == -1)  // 职工不存在
{
cout << "查无此人，修改失败！" << endl;
}
else
{
// 显示职工信息
this->m_EmpArray[index]->showInfo();

// 删除原职工对象并准备创建新对象
delete this->m_EmpArray[index];

// 输入新的职工信息
int NewId, NewSelect;
string NewName;

// 确保新的职工ID不重复
while (true)
{
cout << "请输入新的职工号：" << endl;
cin >> NewId;
int index = this->isExist(NewId);
if (index == -1)  // 新ID未被占用
break;
else
cout << "此职工ID已存在，请重新输入：" << endl;
}

// 输入新的职工姓名
cout << "请输入新的职工姓名：" << endl;
cin >> NewName;

// 输入新的职工岗位
cout << "请选择新的职工岗位：" << endl;
cout << "1、普通职工" << endl;
cout << "2、经理" << endl;
cout << "3、老板" << endl;
cin >> NewSelect;

// 创建新的职工对象
Worker* worker = NULL;
switch (NewSelect)
{
case 1:
worker = new Employee(NewId, NewName, NewSelect);
break;
case 2:
worker = new Manager(NewId, NewName, NewSelect);
break;
case 3:
worker = new Boss(NewId, NewName, NewSelect);
break;
default:
break;
}

// 更新职工数组中的信息
this->m_EmpArray[index] = worker;
cout << "修改成功！" << endl;

// 保存修改后的数据
this->save();
}

// 暂停并清屏
system("pause");
system("cls");
}

8.3 测试修改职工

在 main 函数的分支 4 选项中，调用 Mod_Emp() 接口进行修改职工功能的测试。测试时分别考虑修改不存在职工和修改已存在职工两种情况。

测试 1 - 修改不存在职工情况

测试效果：当输入不存在的职工编号时，程序会输出“查无此人，修改失败”提示。

测试 2 - 修改存在职工情况，例如将职工 “张三” 改为 “张新三”

测试效果：修改成功后，系统会显示“修改成功！”并保存修改后的职工信息。

改后再次查看所有职工信息，并确认修改成功

确认文件中的信息同步更新

测试效果：打开文件，确认修改后的职工信息已正确更新，保存的数据与程序中的显示一致。

至此，修改职工功能已完整实现。测试代码可以在调试完成后进行注释或删除。

9、查找职工

功能描述：提供两种查找职工方式，一种按照职工编号查找，一种按照职工姓名查找。

9.1 查找职工函数声明

在 workerManager.h 中添加成员函数 void Find_Emp();，用于查找职工信息。

1
2

//查找职工
void Find_Emp();

9.2 查找职工函数实现

在 workerManager.cpp 中实现成员函数 void Find_Emp();，该函数根据用户选择的方式查找职工。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

void WorkerManager::Find_Emp()
{
// 判断文件是否为空
if (this->m_FileEmpty)
{
cout << "文件不存在或者为空，查找失败！" << endl;
return;  // 若文件为空，则退出函数
}
else
{
cout << "请选择你的查找方式：" << endl;
cout << "1、按职工编号查找" << endl;
cout << "2、按职工姓名查找" << endl;
int select;
cin >> select;

// 按照职工编号查找
if (select == 1)
{
cout << "请输入需要查找的职工id：" << endl;
int id;
cin >> id;
int index = this->isExist(id);
if (index == -1)
{
cout << "查无此人！" << endl;
}
else
{
this->m_EmpArray[index]->showInfo();  // 显示查找到的职工信息
}
}
// 按照职工姓名查找
else if (select == 2)
{
cout << "请输入需要查找的职工姓名：" << endl;
string name;
cin >> name;

int index = -1;
for (int i = 0; i < this->m_EmpNum; i++)
{
if (this->m_EmpArray[i]->m_Name == name)
{
this->m_EmpArray[i]->showInfo();  // 显示所有与该姓名匹配的职工信息
index = 0;  // 标记查找结果
}
}
if (index == -1)
{
cout << "查无此人！" << endl;
}
}
}
// 暂停并清屏
system("pause");
system("cls");
}

9.3 测试查找职工

在 main 函数的分支 5 选项中，调用 Find_Emp() 接口进行查找职工功能的测试。测试时分别考虑按职工编号和按职工姓名查找的不同情况。

测试 1 - 按照职工编号查找 - 查找不存在职工

测试效果：当输入不存在的职工编号时，程序会输出“查无此人！”的提示。

测试 2 - 按照职工编号查找 - 查找存在职工

测试效果：当输入存在的职工编号时，程序会显示该职工的详细信息。

测试 3 - 按照职工姓名查找 - 查找不存在职工

测试效果：当输入不存在的职工姓名时，程序会输出“查无此人！”的提示。

测试 4 - 按照职工姓名查找 - 查找存在职工（如果出现重名，也一并显示，在文件中可以添加重名职工）

例如，添加两个名为“张三”的职工，并按照姓名查找“张三”。

测试效果：当存在重名职工时，程序会显示所有匹配的职工信息，确保用户能够看到所有与输入姓名匹配的职工。

至此，查找职工功能已完整实现。测试代码可以在调试完成后进行注释或删除。

10、排序

功能描述：根据职工编号进行排序，排序的顺序由用户指定。

10.1 排序函数声明

在 workerManager.cpp 中实现成员函数 void Sort_Emp();，该函数将根据用户的选择对职工编号进行排序。

1
2

//排序职工
void Sort_Emp();

10.2 排序函数实现

在 workerManager.cpp 中实现成员函数 void Sort_Emp();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

void WorkerManger::Sort_Emp()
{
// 判断文件是否为空
if (this->m_FileEmpty)
{
cout << "文件不存在或者为空，排序失败！" << endl;
system("pause");
system("cls");
}
else
{
int select;
cout << "请选择需要的排序方式：" << endl;
cout << "1、降序排序" << endl;
cout << "2、升序排序" << endl;
cin >> select;

// 根据选择的排序方式进行排序
for (int i = 0; i < this->m_EmpNum; i++)
{
int minOrMax = i;
for (int j = i; j < this->m_EmpNum; j++)
{
if (select == 1)  // 降序排序
{
if (this->m_EmpArry[j]->m_Id > this->m_EmpArry[minOrMax]->m_Id)
minOrMax = j;
}
else  // 升序排序
{
if (this->m_EmpArry[j]->m_Id < this->m_EmpArry[minOrMax]->m_Id)
minOrMax = j;
}
}
// 交换职工信息
if (minOrMax != i)
{
Worker* temp = this->m_EmpArry[i];
this->m_EmpArry[i] = this->m_EmpArry[minOrMax];
this->m_EmpArry[minOrMax] = temp;
}
}

// 保存排序后的信息并显示
this->save();
this->Show_Emp();
}
}

void WorkerManger::Clear_File()
{
if (this->m_FileEmpty)
{
cout << "文件为不存在或为空，无需操作！" << endl;
system("pause");
system("cls");
}
else
{
cout << "确认清空？此操作无法恢复！文件将会永久删除！" << endl;
cout << "1、确认清空，文件永久删除" << endl;
cout << "任意键取消" << endl;
string select;
cin >> select;
if (select == "1")
{
cout << "确认清空操作请输入“清空”,输入任意内容取消" << endl;
cin >> select;
if (select == "清空")
{
ofstream ofs;
ofs.open(FILENAME, ios::trunc);  // 清空文件
ofs.close();

// 清空职工数组
if (this->m_EmpArry != NULL)
{
for (int i = 0; i < this->m_EmpNum; i++)
{
delete this->m_EmpArry[i];  // 删除职工对象
}
this->m_EmpNum = 0;
this->m_FileEmpty = true;
delete[] this->m_EmpArry;  // 删除职工数组
this->m_EmpArry = NULL;
}
cout << "已清空！" << endl;
}
else
cout << "已取消！" << endl;
}
else
cout << "已取消！" << endl;

system("pause");
system("cls");
}
}

10.3 测试排序功能

在 main 函数的分支 6 选项中，调用排序职工接口进行排序功能的测试。

添加无序职工

首先我们添加一些职工，职工编号是无序的。例如：

测试 - 升序排序

选择升序排序后，职工会根据编号从小到大进行排序。

排序后的文件同步更新：

测试 - 降序排序

选择降序排序后，职工会根据编号从大到小进行排序。

文件同步更新

至此，职工编号排序功能已实现并经过测试，能够按照用户指定的顺序对职工进行升序或降序排序，并且排序结果会同步保存到文件中。

11、清空文件

功能描述：清空文件中记录的职工数据。

11.1 清空函数声明

在 workerManager.cpp 中实现 void Clean_File();，该函数将删除文件中的所有数据，并清空职工记录。

1
2

//清空文件
void Clean_File();

11.2 清空函数实现

在 workerManager.cpp 中实现 void Clean_File();，该函数将删除文件中的所有数据，并清空职工记录。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

void WorkerManger::Clear_File()
{
if (this->m_FileEmpty)
{
cout << "文件为不存在或为空，无需操作！" << endl;
system("pause");
system("cls");
}
else
{
cout << "确认清空？此操作无法恢复！文件将会永久删除！" << endl;
cout << "1、确认清空，文件永久删除" << endl;
cout << "任意键取消" << endl;
string select;
cin >> select;
if (select == "1")
{
cout << "确认清空操作请输入“清空”，输入任意内容取消" << endl;
cin >> select;
if (select == "清空")
{
// 打开文件进行清空操作
ofstream ofs;
ofs.open(FILENAME, ios::trunc);  // 清空文件内容
ofs.close();

// 删除职工数组内容
if (this->m_EmpArry != NULL)
{
for (int i = 0; i < this->m_EmpNum; i++)
{
delete this->m_EmpArry[i];  // 删除每个职工对象
}
this->m_EmpNum = 0;
this->m_FileEmpty = true;
delete[] this->m_EmpArry;  // 删除职工数组
this->m_EmpArry = NULL;
}
cout << "已清空！" << endl;
}
else
cout << "已取消！" << endl;
}
else
cout << "已取消！" << endl;

system("pause");
system("cls");
}
}

11.3 测试清空文件

在 main 函数的分支 7 选项中，调用清空文件接口进行测试。

测试 - 确认清空文件

在执行清空文件操作时，系统会询问是否确认清空文件数据，并要求输入确认内容。

清空操作成功后，文件中的数据将被清除，可以通过打印文件内容来确认。

再次查看文件中数据，记录已为空

手动打开文件查看，文件内容已被完全清空：

• 文件数据已确保清空，该功能需要慎用！

随着清空文件功能的实现，本项目的基于多态的职工管理系统已经完整实现！至此，所有主要功能（增加、删除、修改、查找、排序、清空文件等）已经完成，可以满足基本的职工管理需求。

3、退出功能

在本节中，我们展示了完整的main函数代码，该代码是整个职工管理系统的入口。main函数通过循环和用户输入来控制系统的操作，支持添加、显示、删除、修改、查找、排序职工，以及清空文件等功能。代码中的各个功能通过switch语句进行选择，并对应调用WorkerManger类中的相应成员函数。

3.1 提供功能接口

在 main 函数中提供分支选择，提供每个功能接口

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <iostream>
#include "workerManger.h"
using namespace std;

// 定义操作菜单的选项
enum choice { Exit, Add, Show, Del, Modify, Find, Sort, Clean };

int main()
{
    // 创建一个WorkerManger对象 wm，用于管理职工信息
    WorkerManger wm;

    // 进入主菜单，用户可以根据输入选择操作
    while (true)
    {
        wm.Show_Menu();  // 显示系统菜单
        int choice;
        cout << "请输入您的选择：" << endl;  // 提示用户输入操作选择
        cin >> choice;  // 获取用户选择

        // 根据用户的选择执行不同的功能
        switch (choice)
        {
        case Exit:    // 退出系统
            wm.EsixSystem();  // 调用退出系统函数
            break;
        case Add:    // 添加职工
            wm.Add_Emp();  // 调用添加职工函数
            break;
        case Show:    // 显示职工信息
            wm.Show_Emp();  // 调用显示职工信息函数
            break;
        case Del:    // 删除职工
            wm.Del_Emp();  // 调用删除职工函数
            break;
        case Modify:    // 修改职工信息
            wm.Mod_Emp();  // 调用修改职工信息函数
            break;
        case Find:    // 查找职工
            wm.Find_Emp();  // 调用查找职工函数
            break;
        case Sort:    // 排序职工
            wm.Sort_Emp();  // 调用排序职工函数
            break;
        case Clean:    // 清空文件数据
            wm.Clear_File();  // 调用清空文件函数
            break;
        default:
            system("cls");  // 如果输入无效，清屏
            break;
        }
    }

    return 0;  // 程序结束
}

代码说明：

1. 菜单选择与操作：通过enum choice定义了所有可能的菜单选项，并使用switch语句根据用户输入的选择执行相应的功能。每个case语句对应一个功能模块，如添加职工、显示职工、删除职工等。
2. 循环运行：程序通过while(true)进入一个无限循环，用户输入选择后，系统根据选择执行操作，直到用户选择退出系统。
3. 操作执行：每个功能模块调用WorkerManger类中的成员函数来实现具体操作。例如，wm.Add_Emp()表示调用Add_Emp函数来添加职工。
4. 退出系统：当用户选择退出时，调用wm.EsixSystem()来终止程序。

通过这种结构，main函数实现了职工管理系统的菜单化控制，使得程序的操作更加直观和易于扩展。

3.2 实现退出功能

在 workerManager.h 中提供退出系统的成员函数 void exitSystem();

在 workerManager.cpp 中提供具体的功能实现

1
2
3
4
5
6

void WorkerManger::EsixSystem()
{
cout << "正在安全退出…… 欢迎下次使用！" << endl;
system("pause");
exit(0);
}

13、 总结

在本次职工管理系统的开发过程中，我们实现了基于 C++的面向对象管理系统，通过类和多态的组合，实现了职工信息的管理。各个功能模块的实现使得职工的管理操作非常灵活，并且系统支持文件的持久化存储，能够在程序关闭后仍保留职工数据。

• 面向对象设计：我们通过继承和多态实现了不同职工类型的统一管理，使得系统结构更清晰，易于扩展。每个职工类型（如员工、经理、老板）都继承自一个基类Worker，并根据岗位需求修改或添加特有的行为。
• 模块化设计：各个功能如职工增加、删除、修改、查找等，都封装成独立的函数，并且与文件操作结合紧密，确保数据的一致性和持久性。这种模块化设计不仅保证了系统的可维护性，也便于后续功能的扩展。
• 灵活性与健壮性：在各个功能的实现中，我们考虑了不同的异常情况处理。例如，在删除职工时检查职工是否存在，在修改职工时避免重复编号，在排序职工时确保排序的准确性。这些细节保证了系统的稳定性和可靠性。

通过这次开发，我们实现了一个完整的职工管理系统，涵盖了职工的增、删、改、查、排序和文件管理等基本功能。这个系统不仅展示了如何使用 C++中的面向对象编程（OOP）思想，还通过文件操作确保了数据的持久化存储。系统的实现为以后开发更复杂的管理系统奠定了基础。

致谢：

感谢 ChatGPT 对本文文本部分的指导与修改！这大大节省了本文的创作时间。

感谢 ChatGPT 对本文部分代码注释的补充！为代码的阅读提供了更佳的便利与体验。

代码原创，需要本项目源码请通过评论区、我的-留言板或邮箱联系免费获取。

通讯录管理系统几乎是我们学习 C++的道路上遇到的第一个“大项目”了，几乎每个学校都会拿他当做一次大作业，最近想要重新熟悉 C++，不妨来试试这个经典项目。

本次我们不使用链表，而是单纯地使用结构体来实现项目的所有功能。

1、系统需求

通讯录是一个可以记录亲人、好友信息的工具。

本教程主要利用 C++来实现一个通讯录管理系统

系统中需要实现的功能如下：

• 添加联系人：向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多记录 1000 人
• 显示联系人：显示通讯录中所有联系人信息
• 删除联系人：按照姓名进行删除指定联系人
• 查找联系人：按照姓名查看指定联系人信息
• 修改联系人：按照姓名重新修改指定联系人
• 清空联系人：清空通讯录中所有信息
• 退出通讯录：退出当前使用的通讯录

2、项目的实现

根据需求，我们可以设计两个结构体来实现这些需求。首先是联系人结构体，包含姓名、年龄、性别、手机号码、家庭住址等信息。其次是一个通讯录结构体，包含联系人结构体数组，以及记录联系人数量的参数。然后，我们绘制菜单输出样式，最后依次实现各个功能函数。

2.1 菜单功能

功能描述： 用户选择功能的界面

菜单界面效果如下图：

步骤：

• 封装函数显示该界面 如 void showMenu()
• 在 main 函数中调用封装好的函数

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 显示菜单界面的函数
void showMenu()
{
    cout << "***************************" << endl;
    cout << "*****  1、添加联系人  *****" << endl;
    cout << "*****  2、显示联系人  *****" << endl;
    cout << "*****  3、删除联系人  *****" << endl;
    cout << "*****  4、查找联系人  *****" << endl;
    cout << "*****  5、修改联系人  *****" << endl;
    cout << "*****  6、清空联系人  *****" << endl;
    cout << "*****  0、退出通讯录  *****" << endl;
    cout << "***************************" << endl;
}

2.2 添加联系人

功能描述：

实现添加联系人功能，联系人上限为 1000 人，联系人信息包括（姓名、性别、年龄、联系电话、家庭住址）

添加联系人实现步骤：

• 设计联系人结构体
• 设计通讯录结构体
• main 函数中创建通讯录
• 封装添加联系人函数
• 测试添加联系人功能

2.2.1 设计联系人结构体

联系人信息包括：姓名、性别、年龄、联系电话、家庭住址

设计如下：

1
2
3
4
5
6
7
8
9
10

// 定义联系人结构体
struct Person
{
    string m_Name;   // 姓名
    int m_Sex;       // 性别：1-男，2-女
    int m_Age;       // 年龄
    string m_Phone;  // 联系电话
    string m_Addr;   // 家庭住址
};

2.2.2 设计通讯录结构体

在通讯录结构体中，维护一个容量为 1000 的联系人数组，并记录当前通讯录中的联系人数量。

设计如下

1
2
3
4
5
6
7

// 定义通讯录结构体
struct Addressbooks
{
    Person personArray[MAX];  // 存储联系人信息的数组
    int m_Size;               // 当前通讯录中联系人数量
};

记得先定义宏定义 MAX 值。

2.2.3 main 函数中创建通讯录

添加联系人函数封装好后，在 main 函数中创建一个通讯录变量，这个就是我们需要一直维护的通讯录。

1
2
3
4

// 在main函数中创建通讯录
struct Addressbooks abs;
abs.m_Size = 0;  // 初始化通讯录中联系人数量为0

2.2.4 封装添加联系人函数

思路： 添加联系人前，先判断通讯录是否已满，如果满了就不再添加；未满情况下，将新联系人信息逐个加入到通讯录。

添加联系人代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// 添加联系人函数
void addPerson(Addressbooks *abs)
{
    // 判断通讯录是否已满
    if (abs->m_Size == MAX)
    {
        cout << "通讯录已满，无法添加" << endl;
        return;
    }

    // 输入联系人信息
    string name;
    cout << "请输入姓名：" << endl;
    cin >> name;
    abs->personArray[abs->m_Size].m_Name = name;

    int sex = 0;
    cout << "请输入性别：" << endl;
    cout << "1 --- 男" << endl;
    cout << "2 --- 女" << endl;
    while (true)
    {
        cin >> sex;
        if (sex == 1 || sex == 2)
        {
            abs->personArray[abs->m_Size].m_Sex = sex;
            break;
        }
        cout << "输入有误，请重新输入" << endl;
    }

    cout << "请输入年龄：" << endl;
    int age = 0;
    cin >> age;
    abs->personArray[abs->m_Size].m_Age = age;

    cout << "请输入联系电话：" << endl;
    string phone;
    cin >> phone;
    abs->personArray[abs->m_Size].m_Phone = phone;

    cout << "请输入家庭住址：" << endl;
    string address;
    cin >> address;
    abs->personArray[abs->m_Size].m_Addr = address;

    // 更新通讯录中的联系人数量
    abs->m_Size++;

    cout << "添加成功！" << endl;

    // 暂停并清屏
    system("pause");
    system("cls");
}