——我们四个人，在一个下午，听孔师傅把 40 年讲完

2026-10-04 15:20

10月4日下午，我们走进天水街道仓桥社区玄坛弄8号。这是一间 100 平方米的"工作室"。

屋里最显眼的位置摆着一辆 28 路公交车的模型——那是孔师傅自己开过的那一款车，后来做成模型在展览上展出，他就把模型搬到了自己的工作室。

我们是浙江省杭州高级中学的学生记者，国庆节来采访他。推门之前，我们准备的问题里写着"坚持免费修车 30 多年"。真正见到他、坐下不到一分钟，这个数字就被他自己改了。

挂钟走着，我们听着他把 42 年讲了一遍。

一、他先纠正了我们

"停一下，你稍微停一下吧——40 年。"

开场白里我们说"您坚持了 30 多年免费为群众修车"，他立刻抬手打断我们："1986 年 3 月 5 号嘛，现在 40 年了。"

那一年他 22 岁。在他嘴里，40 年不是一个修车摊的数字，而是一条完整的时间线：机修钳工 10 年、乘务员 4 年、驾驶员 27 年，加起来 42 年公交工作。

这是我们的采访里，他纠正我们的第一处。他后来还纠正了我们提到的工龄"38 年还是 40 年"——他记得特别清楚。

二、三份请调报告：他偏往最苦的地方去

1982 年 11 月，18 岁的孔胜东进杭州公交大修厂当机修钳工。"那一个月休四天，九点上班，中午半小时吃饭，下午四点下班，生活很有规律。"他把那十年叫"轻松"。

后来改革开放，客车厂、大修厂相继倒闭，"乘务员、驾驶员一个月都休不到一天"。他打了两份、后来是三份请调报告，要求去当乘务员。领导问他怕不怕，他答："我不怕，越是艰苦的地方，越能锻炼我们年轻人的意志。"

1993 年 1 月 2 日，28 路多了一名乘务员。1996 年 8 月，28 路开始无人售票，乘务员又"多出来了"——他再打三份报告，去学驾驶。1996 年 8 月到 1997 年 8 月，一年学成；1997 年 8 月 13 日，重新回到 28 路，一直开到 2024 年 8 月 30 日。

我们问，三个岗位您都喜欢，图什么？他说：是"改革的时候"，时代在调整，他只是跟着时代走，"走到了最需要人的地方"。

三、31 年，他坚持用嗓子人工报了一遍站

28 路全线自动报站，但他做了 31 年"人声版"。

"31 年来我的喉咙到现在还哑。"他笑得很平静，"但每当服务好我们的居民、市民、外地游客的时候，我觉得做一名公交司机非常骄傲和自豪。"

"一个公交车就是流动的家。"

2024 年 8 月 30 日退休那天，有位大妈追着问他："孔师傅，你工作退休了，你这个义务修车点也退休了吗？"他当场承诺："只要我有一口气，我会一直坚持地干下去，直到我干不了为止。"

四、两个梦想

"我 42 年来有两个梦想：第一个梦想就是开一辈子公交车，第二个梦想就是做一辈子志愿者。"

第一个梦想，2024 年 8 月 30 日实现了——他驾驶最后一班 28 路，从起点开到终点，85.09 万公里，安全行驶。

第二个梦想，他正在为之奋斗。

2024 年 9 月 2 日，在天水街道和仓桥社区的支持下，"杭州市拱墅区孔胜东公益事业发展中心"成立。他成了专职社区志愿者：每周六晚 7 点到 10 点，在中山北路 358 号门前免费义务修车；平日助残助老、平安巡防、平安护河、反诈、反邪、禁毒宣传；服务空间每周二到周六开馆，周一闭馆。

这里还是杭州第一家以个人名字命名的社区工会驿站，门外挂着"杭州市劳模工匠之家""劳模工作室""新时代文明实践点"的牌子。100 个平方，环卫工人、快递小哥、公交司机、保安、收费员可以进来歇歇脚、喝口水、吹吹空调，"谈谈自己的酸甜苦辣"。

从"流动的家"到"固定的家"，他也在学着做"社区的儿子"：老居民区老人特别多，他跑到街道和社区反映能不能建个老年食堂——"群众的小事就是大事"。

五、一个人的善意，怎么变成一群人的习惯

1986 年 3 月 5 日，他一个人学雷锋。40 年后，这支队伍有了名字：杭州公交孔胜东志愿者服务队。

2007 年前后，他到杭州交通职高做了一场报告。讲完以后，"学校的老师、家长、同学三方面决定加入我的志愿者队伍"。现在他有 150 个徒弟，每周六换一批，一批 15 人左右。下雨天来的"不到 15 个，12 个、11 个"——"新来的女孩子，手弄得脏脏的"。他说："不要怕脏、怕累、怕苦。"

他给"当志愿者"划了条件："一个是愿意做志愿者，第二个是要有技术的志愿者。" 光有热情不够，会修车才是真本事。

"我 38 年从来没有利用 1 分钟的工作时间做志愿者。8 小时以内做好本职工作，8 小时以外做志愿者。"

"40 年来没人监督我。单位都放假了，我不要紧——因为居民有需求，所以最大的监督就是群众对我的监督。"

访谈那天他告诉我们，前一晚下大雨，他还记得我们中的两位同学冒雨去看过他。他说，那些天里有的同学口头上说"下雨就不来了"，而他"风雨无阻"。

他还提到一位大妈，两个月没来修车点——后来才弄明白，是跟老伴拌嘴摔了腿，两个月没出门。

"群众的眼睛是雪亮的。"

六、他想让我们记住的，其实是很小的事

这一段是他讲得最慢、也最像"聊天"的一段。几乎每一句都是对着我们这个年龄说的。

• 关于读书：我们的读书不是为爸爸妈妈、外公外婆、爷爷奶奶而读，也不是为老师而读。"一定要自觉读书、用心读书、快乐读书、幸福读书。考得好不要骄傲，考得不好也不要气馁。"
• 关于做事：他反复用"不怕"收尾——不怕苦、不怕累、不怕脏、不怕压力，"压力也是动力"。工作上，"检查和不检查一个样"，领导在不在一个样。
• 关于劳动：他说："你烧得再难吃，也比爸爸妈妈烧的好吃——这就是自己劳动的体会。"国庆节在家，可以试试自己起床上、整理被子、烧饭、收碗、洗碗、扫地。
• 关于同学：一个小组的同学流感请了一个星期假，回来以后，同学给他补课，"效果比老师补课还好，因为大家熟，他听得进去"；事没做完的，我们帮他做。"我们是个团体。"
• 关于路上：上学去，红灯停、绿灯行；看见外卖小哥要闯红灯，我们可以劝一句"哥哥，现在红灯"；坐公交文明排队，坐地铁有序上车，看见老人扶一下。

"雷锋的精神，我总结就是从小事做起，从身边做起，从一点一滴、一步一步做起。"

"做志愿者累不累？累是假的。"他说，"你做了以后可能爸爸都不会表扬你，但那位奶奶会表扬你——'这个奶奶表扬我了，还要谢谢我'——你觉得，你的价值就在这儿。"

"我们年轻人不缺钱。越幸福的时代，越要想到去付出。"

他还提到自己现在在新兴事物上不如我们："我电脑玩不过你们，是吧？我 42 年过来了，退休两年 44 年了，但是理论方面，你们越学越高，我也要向你们学习。"路上遇到七八十岁的老人不会用手机、问路的时候如果我们指一下，"我觉得做一名志愿者非常的骄傲和自豪"。

"我们的公交、地铁、银行、医院，三百六十行行行出状元。希望你们未来都是劳模、都是工匠。"

七、62 岁生日那天，他对着一本旧书想通的事

"我是 1964 年 9 月 1 号出生。小时候听着雷锋的故事、唱着雷锋的歌、看着雷锋的电影长大。"

"我最喜欢雷锋日记里的两篇：一篇是'干一行、爱一行、专一行、精一行'；另一篇是'人的生命是有限的，而为人民服务是无限的，我要把有限的生命投入到无限的为人民服务之中去'。这两篇日记一直激励了我 63 年的成长。"

上世纪 80 年代末，风言风语并不少。"孔师傅傻瓜是不是？""不用挣啊。"他讲起自己跑革命烈士纪念馆，讲到今年是红军长征胜利 90 周年，讲到 3500 多万革命先烈"连个家都没有，有的那是连名字都没有"。

"那时候我 22 岁开始学雷锋，受点风言风语的委屈，跟革命先烈的先进事迹相比，微不足道。所以我更坚定了，就把这一本书坚持下来。"

"你们碰到困难的时候，想想革命历史。你所有的困难、所有的烦恼，一扫而过。"

八、寄语

采访的最后，我们请他给杭高学子留一句话。他想了想，说了一段和开头差不多、却又更完整的话：

"祝我们杭高所有的同学，在今后的学习、生活、工作中，不管遇到什么困难，都要坚持努力，勤奋，不怕苦，不怕累，不怕脏，好好学习，天天向上，做一个德智体美劳全面发展新时代的好少年。"

说完他补了一句："继续努力！"

临走时他还在张罗——"你让你爸去开一下门，右面最后一个看一下"，让我们等等再走，怕我们漏下什么。门关上了，屋里安静下来。

窗外是杭州的傍晚，26 路、28 路还在按点发车。他和他的 150 个徒弟，正在这个城市里，做着一件没有终点的事。

我们最想记下来的三句话：

1. 我们的公交车有起点和终点，但是为人民服务只有起点，没有终点。只要我干得动，我会一直干下去，直到我干不动为止。
2. 荣誉只能代表过去，一切从零开始。不要为荣誉而做，要踏踏实实自己做。
3. 雷锋的精神，从小事做起，从身边做起，从一点一滴、一步一步做起。

后记：我们听说过、记录过很多"坚持"，最后都会落在某一个具体的动作上——一个人的 31 年人工报站，一场雨也拦不住的周六义务修车，一份又一份的请调报告，一间 100 平方米里常年开着的门。孔师傅说，荣誉只能代表过去。而对我们这些还没走出校门的学生，他最实在的建议是：先把自己的 8 小时过好，剩下的时间，去替陌生人扶一下那把站不稳的椅子。

（本文为浙江省杭州高级中学学生记者国庆节实地访谈整理）

辛辛苦苦改了一晚上代码，原本能跑，更新后如果出了问题就难以回滚亦或是修复，只能盯着空白发呆；

和别人一起开发项目，QQ互传压缩包，有时也不知道对方改了哪里，遇到报错更是头晕，只能对七八个版本傻眼——到底哪个能用？

调侃之余，有群友说：“你们该用版本管理。”

那是我第一次听说这个词。

什么是版本管理？

简单说，版本管理就是给你的代码“拍照片”。

想象一下你写文档。写完一稿，存成“报告v1.docx”。改了点，存成“报告v2.docx”。又改了点，存成“报告最终版.docx”。再改，变成“报告真的最终版.docx”。

这就是最原始的版本管理——手动命名，手动备份。问题很明显：版本多了就乱，想找回某个中间版本得一个个打开看。

专业的版本管理系统，就是帮你自动化这个过程的工具。它会：

1. 记录每次改动的内容
2. 记录谁在什么时候改的
3. 记录为什么要改
4. 让你随时回到任意历史版本

在Git出现前，已经有CVS、Subversion这样的版本控制工具。但它们都有个共同问题：必须连接中央服务器。这就像在图书馆借书——书只有一本，你得登记谁借走了，别人得等着。

Linus的“十日革命”

2005年，Linux内核开发团队就面临这样的困境。他们用的BitKeeper突然要收费，而现有的开源工具又满足不了需求。

Linux之父Linus Torvalds后来在采访中说：“当时的情况是，要么我们继续用不合适的工具，要么我自己造一个合适的。”他选择了后者。

4月3日，Linus开始写Git。他在设计文档里写了三个目标：

1. 速度要比其他工具快十倍
2. 完全分布式，不需要中央服务器
3. 能处理像Linux内核这样的大项目

十天后，Git第一个版本发布。4月16日，Linus用Git管理Linux内核源码。4月20日，他宣布Git已经能自我托管——用Git来管理Git自己的代码。

早期的Git很难用。命令复杂，概念抽象。有开发者抱怨：“这玩意儿比Linux内核还难懂。”Linus的回复很直接：“不爽不要用。”

但Git有两个设计太超前了：

第一，分布式架构。每个人的电脑上都有完整的仓库历史，不需要联网也能提交代码。这就像每个人都有一本完整的图书馆目录，不需要去总馆查资料。

第二，分支管理。分支是同时控制不同版本代码的绝佳工具。例如，你希望在稳定版代码的基础上加点新功能，就可以基于主分支创建新分支，在新分支上随意更改，这让“尝试性开发”成为可能——想到什么点子，开个分支试试，不行就删掉。

GitHub：让Git飞入寻常百姓家

Git很强，但直到2008年，它主要还是极客在用。直到三个年轻人创立了GitHub。

GitHub做了件简单但革命性的事：给Git套了个网页界面。

突然之间，事情变得直观了。代码仓库变成网页，提交历史变成时间轴，分支合并变成可视化操作。更重要的是，他们创造了Pull Request（PR，拉取请求）。这是GitHub最伟大的创新。你不再需要邮件发送补丁，而是：

1. Fork（复制）别人的仓库
2. 在自己的副本上修改
3. 发起Pull Request，请求原作者合并你的修改
4. 在PR中进行代码审查、讨论

这种模式极大地降低了开源贡献的门槛。2015年，微软将.NET框架开源并放到GitHub上时，社区震惊了。这个曾经视开源为敌的公司，现在主动拥抱开源。

我清楚地记得第一次在GitHub上提交PR的场景。那是个朋友的开源小项目，我发现文档内容有误。点了“Fork”按钮，把项目复制到我的账户。修改，提交，然后发起PR。项目维护者看到了，点了个“Merge”。两分钟后，我的修改成了项目的一部分。

那种感觉很难形容——好像突然之间，我也能为那些遥不可及的大项目做贡献了。

GitHub火了。到2012年，它已经有超过200万个仓库。Ruby on Rails、jQuery、Node.js这些知名项目都搬了上去。微软也把.NET框架开源放到了GitHub，这在以前是不可想象的。

GitHub的成功引来了竞争者。2011年，GitLab诞生。它的卖点是“可以自己部署”。企业可以把GitLab装在自己的服务器上，代码不出内网。除了代码托管，它还集成了：

• CI/CD流水线：自动测试、构建、部署
• 问题追踪：bug报告、功能请求
• Wiki：项目文档
• 代码质量分析：自动化代码检查

中国这边，2013年出现了Gitee（码云）。起初很多人觉得“是山寨GitHub”，但后来发现了它的价值：国内访问快，符合中国法规，还有中文界面。

不只是代码

Git的影响远远超出了编程世界。

• 学术研究：学者用Git管理论文草稿，每次修改都有记录
• 法律文件：律师事务所用类似Git的系统管理合同版本
• 图书出版：出版社用Git协调作者、编辑、校对的工作
• 政府文档：有些政府部门用Git追踪政策文件的修订

实际怎么用？

第一步：初始化与配置

先安装Git，安装步骤略。

开始前，先告诉Git你是谁：

git config --global user.name ”你的名字“
git config --global user.email ”你的邮箱“

这很重要，因为Git的所有提交都会记录作者信息。

创建一个新仓库：

mkdir my-project # 新建一个名为“my-project”的文件夹
cd my-project # 进入该文件夹
git init # Git仓库初始化

执行git init后，当前目录会出现一个隐藏的.git文件夹。这就是Git的“大脑”，里面存储着所有的版本信息、配置和索引。

或者，你也可以直接下载云端仓库：

git clone https://github.com/username/repo.git # 此处链接为你仓库的实际在线链接，clone就是“克隆”的意思，会把仓库下载到当前目录下
cd repo # 进入仓库文件夹，文件夹名称为仓库名

查看仓库状态：

git status

这是你最常用的命令之一。它会告诉你：

• 哪些文件被修改了但还没暂存（红色）
• 哪些文件已经暂存等待提交（绿色）
• 是否有未跟踪的新文件

第二步：基础工作流

假设你写了一个简单的Python脚本：

# hello.py
print(”Hello, World!“)

把文件添加到暂存区：

git add hello.py # add后为你的实际文件名

或者添加所有修改：

git add . # .表示所有文件

暂存区（Staging Area）是Git的精妙设计。它就像购物车——你可以把多个改动放进去，最后一次性结账。这让你可以精心组织每次提交的内容。

正式提交：

git commit -m ”添加hello.py脚本“

每次提交都应该有一个清晰的描述。好的提交信息应该像新闻标题：简明扼要地说明做了什么。比如：

• ❌ 错误：”修复bug“、”更新代码“
• ✅ 正确：”修复用户登录时的空指针异常“、”添加用户头像上传功能“

目前业界公认度最高的提交信息标准是 Conventional Commits（约定式提交）。它最初源于 Angular 团队的规范，现在已成为许多开源项目（如 Vue、React、Babel 等）和大型团队的通用标准。

1. 核心格式

遵循<type>(<scope>): <description>的结构，例如：

• feat(auth): add OAuth2 login flow
• fix(ui): correct button alignment on dashboard

2. 关键规则

• 类型 (Type)：必须使用特定关键词，如 feat（新功能）、fix（修复）、docs（文档）、style（格式）、refactor（重构）、test（测试）、chore（构建/工具）等。
• 时态：使用现在时（如 ”add“ 而非 ”added“），且首字母不大写。
• 长度：标题行建议不超过 50 字符，正文行建议不超过 72 字符。
• 空行：标题与正文之间必须有一个空行。

3. 为什么用这个标准？

• 自动化工具：能自动生成 CHANGELOG（更新日志）。
• 语义化版本：能根据 feat 和 fix 自动决定版本号升级（如 1.0.0 → 1.1.0）。
• 可读性：让代码历史像一本清晰的说明书，便于团队协作。

查看提交历史：

git log

默认显示完整的提交信息。如果想要简洁视图：

git log --oneline --graph --all

这会显示一个可视化的分支图，特别适合查看复杂的分支结构。

第三步：撤销与回滚

写代码难免犯错，Git提供了多种“后悔药”。

场景1：还没暂存就发现写错了

# 放弃某个文件的修改
git checkout -- hello.py

# 放弃所有修改（危险！请确认你真的不需要这些修改）
git checkout -- .

场景2：已经暂存但想撤销

# 把文件从暂存区移出，但保留修改
git reset HEAD hello.py

# 然后可以用checkout放弃修改
git checkout -- hello.py

场景3：已经提交但想撤销

# 查看提交历史，找到要回退的版本
git log --oneline

# 假设我们看到：
# a1b2c3d 添加新功能
# e4f5g6h 修复bug
# i7j8k9l 初始提交

# 回到修复bug的那个版本
git reset --hard e4f5g6h

--hard参数会彻底丢弃之后的提交，慎用！如果你只是想撤销某个提交但保留更改：

git revert e4f5g6h

这会创建一个新的提交来撤销指定提交的修改，更安全。

第四步：分支管理

分支是Git最强大的功能之一。它让你可以：

• 同时开发多个功能
• 安全地实验新想法
• 隔离bug修复和功能开发

创建并切换到新分支：

git checkout -b new-feature

这等价于：

git branch new-feature    # 创建分支
git checkout new-feature  # 切换分支

在新分支上开发完成后，切换回主分支并合并：

git checkout main
git merge new-feature

如果合并顺利，Git会执行“快进合并”（Fast-forward）。如果有冲突，Git会提示你解决。

删除已合并的分支：

git branch -d new-feature

强制删除未合并的分支：

git branch -D experimental

查看所有分支：

git branch     # 本地分支
git branch -r  # 远程分支
git branch -a  # 所有分支

第五步：远程协作

本地Git再强大，也需要与团队协作。这就是远程仓库的用武之地。

添加远程仓库：

git remote add origin https://github.com/username/repo.git

origin是远程仓库的默认别名，你可以用其他名字。

查看远程仓库：

git remote -v

推送本地提交到远程：

git push origin main

第一次推送时可能需要指定上游分支：

git push -u origin main

-u参数设置上游关联，之后可以直接用git push

拉取远程更新：

git pull origin main

这等价于：

git fetch origin   # 下载远程更新
git merge origin/main  # 合并到当前分支

有时候你只想查看远程有什么更新，而不想立即合并：

git fetch origin
git log origin/main --oneline  # 查看远程分支的提交

第六步：处理冲突

冲突是团队协作的必经之路。当两个人修改了同一文件的同一区域时，Git无法自动合并，需要人工解决。

发生冲突时，Git会在文件中标记冲突：

<<<<<<< HEAD
print(”Hello from Alice!“)
=======
print(”Hello from Bob!“)
>>>>>>> feature-branch

你需要：

1. 编辑文件，选择保留哪部分（或都保留）
2. 删除冲突标记（<<<<<<<、=======、>>>>>>>）
3. 添加解决后的文件：git add filename
4. 完成合并：git commit

查看合并状态：

git merge --abort  # 取消合并，回到合并前状态
git status         # 查看当前冲突文件

第七步：高级技巧

储藏更改（Stashing）：

当你需要切换分支但当前工作还没完成时：

git stash          # 储藏当前修改
git stash list     # 查看储藏列表
git stash pop      # 应用最新的储藏并删除
git stash apply    # 应用储藏但不删除

查看差异：

git diff                    # 工作区与暂存区的差异
git diff --staged          # 暂存区与最新提交的差异
git diff commit1 commit2   # 两个提交之间的差异

重写历史（谨慎使用！）：

修改最后一次提交：

git commit --amend

交互式变基（修改多个提交）：

git rebase -i HEAD~3  # 修改最近3个提交

子模块（Submodules）：

用于在项目中包含其他Git仓库：

git submodule add https://github.com/other/repo.git
git submodule update --init --recursive

实际工作流示例

让我分享一个真实的工作流。假设我们要开发一个新功能：

1. 从最新代码开始

git checkout main
git pull origin main

2. 创建功能分支

git checkout -b feature/user-profile   

3. 开发、测试、提交

# 多次小提交，而不是一次大提交
git add user/profile.py
git commit -m ”添加用户基本信息模型“

git add user/views.py
git commit -m ”实现个人资料页面“

git add tests/test_profile.py
git commit -m ”添加个人资料功能测试“   

4. 推送到远程

git push -u origin feature/user-profile    

5. 创建Pull Request

   • 在GitHub/GitLab上发起PR
   • 同事审查代码，提出建议
   • 根据反馈修改，再次推送
   • 通过CI/CD流水线的自动化测试
   • 合并到主分支
6. 清理分支

git checkout main
git pull origin main
git branch -d feature/user-profile 

改变了什么？

Git和它的衍生平台改变了三件事：

第一，降低了协作门槛。以前贡献开源项目要发邮件、下源码包、打补丁。现在点个Fork，改完提交PR就行。这让开源从“精英游戏”变成了“全民运动”。

第二，让工作流标准化。无论你在哪个公司，用的都是相似的Git工作流。新人入职，半天就能上手代码管理流程。

第三，创造了新的职业。DevOps工程师、平台开发，这些岗位很大程度上是因为Git生态出现的。

但最深层的改变，是思维方式的转变。

我现在写代码时的心态完全不同了。知道有Git托底，就敢尝试激进的重构。知道分支是安全的，就敢同时开展多个实验性功能。知道每次提交都有记录，写commit message时会更认真。

尾声

有时候我会想，如果2005年Linus没被逼到必须自己写工具，今天的世界会怎样？

可能我们还在用QQ传代码压缩包。可能开源不会这么繁荣。可能远程协作还是噩梦。

但历史没有如果。一个脾气暴躁的程序员，花了十天时间解决自己的问题，顺便解决了全世界程序员的问题。

这就是技术的魅力——最好的工具往往诞生于具体的困境，却解决了普遍的需求。

现在每次我开始新项目，都会习惯性地git init。这个简单的动作，连接着从个人备份到全球协作的整个历史。

而每次git commit时，我知道自己不仅是在保存代码。我是在参与一场持续了将近二十年的革命——一场让创造变得更有序、更协作、更持久的革命。

前几天熬夜写库，追求极简语法、快速上手、丰富功能、跨平台支持，下面，请看~

https://gitee.com/sean537/TC https://github.com/Sean537/TC

TC.hpp - ✨ 跨平台终端控制头文件库

🚀 一个现代化的 C++17 终端控制库，旨在用最简单的语法解决开发过程中会遇到的各种问题。目前功能包括终端彩色输出、延时、进度条、基础控制、系统信息检测、获取时间等，跨平台、零依赖、纯头文件！

✨ 主要特性

• 🖥️ 跨平台：Windows/类Unix终端自动适配
• 🎨 丰富色彩：支持前景色、背景色、RGB、字体样式
• 💡 现代C++17，纯头文件，零依赖
• ⏱️ 延时与打字机特效
• 📊 进度条、链式API、终端尺寸/光标控制
• 🧩 代码风格简洁，易于集成

🚀 快速上手

1. 引入头文件

#include "tc.hpp"

2. 主要用法示例

#include "tc.hpp"

int main() {
    // 🌈 颜色与样式
    tc::tout << TCOLOR_GREEN << "Hello world!" << TCOLOR_RESET << std::endl;
    tc::tout << TFONT_BOLD << "粗体文本" << TFONT_RESET << std::endl;
    tc::tout << TCOLOR_RGB(255,0,0) << "RGB红" << TCOLOR_RESET << std::endl;
    std::cout << tc::red("红色文本") << std::endl;

    // ⏱️ 延时输出
    tc::tout << "Wait..." << std::endl;
    tc::tsleep(1000);
    tc::tout << "Done!" << std::endl;

    // 🖨️ Python风格打印
    tc::print("Hello ", "world!\n");
    tc::println("年龄: ", 25, ", 分数: ", 95.5);
    tc::println(TCOLOR_RED, "红色文本");
    tc::println(TCOLOR_GREEN, BCOLOR_YELLOW, "绿色文字，黄色背景");
    tc::println(TCOLOR_BLUE, BCOLOR_WHITE, TFONT_BOLD, "蓝色粗体，白色背景");

    // 🖋️ Printer链式API
    tc::printer()
        .clear()    // 清屏
        .moveCursor(10,5)
        .print("移动光标到(10,5)")
        .hideCursor()   // 隐藏光标
        .moveCursor(tc::Printer::Direction::Down, 2) // 相对移动（向下2行）
        .println("在(10,7)")
        .println() // 换行
        .showCursor();  // 显示光标

    // 📏 终端尺寸
    auto size = tc::printer().getSize();
    tc::println("终端大小: ", size.first, "x", size.second);

    // ⏳ 进度条
    tc::ProgressBar bar(30, "█", "░", TCOLOR_GREEN);
    for (int i = 0; i <= 100; ++i) {
        bar.show(i / 100.0, "处理中...");
        tc::wait(0.02);
    }
    bar.finish();

    // 🖥️ 执行系统命令
    tc::systemConsole("echo TC systemConsole test");

    // 🕒 获取系统时间
    int year = tc::getSystemTime(SYS_YEAR);
    int month = tc::getSystemTime(SYS_MONTH);
    int day = tc::getSystemTime(SYS_DAY);
    int hour = tc::getSystemTime(SYS_HOUR);
    int minute = tc::getSystemTime(SYS_MINUTE);
    int second = tc::getSystemTime(SYS_SECOND);
    int timestamp = tc::getSystemTime(); // 默认Unix时间戳
    tc::println("当前时间: ", year, "-", month, "-", day, " ", hour, ":", minute, ":", second, " (Unix: ", timestamp, ")");

    // 🛡️ 检查系统环境
    int os = tc::systemCheck();
    const char* osName = tc::getOSName(os);
    std::string osVersionInfo = tc::getOSVersionInfo();

    tc::println("当前系统: ", osName);
    tc::println("系统版本: ", osVersionInfo);

    return 0;
}

🧩 主要API与宏

🎨 颜色与样式

全局颜色宏（直接用）

// 前景色
TCOLOR_RED, TCOLOR_GREEN, TCOLOR_YELLOW, TCOLOR_BLUE, TCOLOR_MAGENTA, TCOLOR_CYAN, TCOLOR_WHITE, TCOLOR_RESET
// 背景色
BCOLOR_RED, BCOLOR_GREEN, BCOLOR_YELLOW, BCOLOR_BLUE, BCOLOR_MAGENTA, BCOLOR_CYAN, BCOLOR_WHITE, BCOLOR_DEFAULT
// 字体样式
TFONT_BOLD, TFONT_FAINT, TFONT_ITALIC, TFONT_UNDERLINE, TFONT_BLINK_SLOW, TFONT_BLINK_FAST, TFONT_REVERSE, TFONT_CONCEAL, TFONT_CROSSED, TFONT_DEFAULT, TFONT_FRAKTUR, TFONT_DOUBLE_UNDERLINE, TFONT_NORMAL, TFONT_NOT_ITALIC, TFONT_NO_UNDERLINE, TFONT_NO_BLINK, TFONT_NO_REVERSE, TFONT_REVEAL, TFONT_NOT_CROSSED, TFONT_THICK, TFONT_RESET
// RGB
TCOLOR_RGB(r, g, b)

颜色控制类（ColorController）

// 设置颜色
tc::ColorController::setColor(tc::ColorController::Color::RED);
std::cout << "红色文本" << std::endl;

// 设置RGB颜色
tc::ColorController::setRGBColor(255, 128, 0);
std::cout << "橙色文本" << std::endl;

// 设置粗体
tc::ColorController::setBold(true);
std::cout << "粗体文本" << std::endl;

// 重置颜色
tc::ColorController::setColor(tc::ColorController::Color::RESET);

便捷颜色函数

⚠ 注意：便捷颜色函数本质上是在字符串头尾添加 ANSI 转义序列，最好不要在输出上滥用，并且部分终端不支持 ANSI 转移序列。想要做文本带颜色输出，推荐移步其它方法。

// 基本颜色函数
std::string coloredText = tc::colorize("彩色文本", tc::ColorController::Color::CYAN);
std::cout << coloredText << std::endl;

// RGB颜色函数
std::string rgbText = tc::colorizeRGB("RGB颜色文本", 255, 128, 0);
std::cout << rgbText << std::endl;

// 标准颜色函数
std::cout << tc::red("红色文本") << std::endl;
std::cout << tc::green("绿色文本") << std::endl;
std::cout << tc::blue("蓝色文本") << std::endl;
std::cout << tc::yellow("黄色文本") << std::endl;
std::cout << tc::cyan("青色文本") << std::endl;
std::cout << tc::magenta("洋红色文本") << std::endl;
std::cout << tc::white("白色文本") << std::endl;

// 亮色函数
std::cout << tc::brightRed("亮红色文本") << std::endl;
std::cout << tc::brightGreen("亮绿色文本") << std::endl;
std::cout << tc::brightBlue("亮蓝色文本") << std::endl;
std::cout << tc::brightYellow("亮黄色文本") << std::endl;

字体样式宏（TFONT_XXX）

⚠️ 兼容性说明：

• TC.hpp 在 Windows 平台上使用 Windows Console API（Win32 API）实现终端控制功能，而不使用 ANSI 转义序列，因此所有字体样式在 Windows 平台上都能完全支持，不受终端对 ANSI 转义序列支持程度的限制。
• Linux/macOS 下使用 ANSI 转义序列实现，主流终端（如 GNOME Terminal、iTerm2、Konsole、Alacritty 等）大多支持常用样式（粗体、下划线、反色、部分斜体/删除线）。
• TFONT_FRAKTUR、TFONT_DEFAULT、TFONT_DOUBLE_UNDERLINE 等为扩展/实验性样式，在非 Windows 平台上支持度较低。

用法示例：tc::println(TCOLOR_RED, BCOLOR_YELLOW, TFONT_BOLD, "红字黄底粗体")

🖥️ 终端控制

tc::terminal命名空间

// 清空屏幕
tc::terminal::clear();

// 移动光标到指定位置
tc::terminal::moveCursor(10, 5);
std::cout << "这是位置(10,5)" << std::endl;

// 获取终端大小
auto [width, height] = tc::terminal::getSize();
std::cout << "终端大小: " << width << "x" << height << std::endl;

tc::Printer链式类

// 创建Printer对象并执行一系列操作
tc::printer()
    .clear()                                  // 清屏
    .hideCursor()                             // 隐藏光标
    .moveCursor(10, 5)                        // 移动到绝对位置
    .println("这是位置(10,5)")                 // 打印并换行
    .moveCursor(tc::Printer::Direction::Down, 2) // 相对移动（向下2行）
    .println("向下移动了2行")
    .moveCursor(1, 10)                        // 移动到第10行开头
    .print("在第10行: ")                       // 打印不换行
    .print("继续在同一行打印")
    .println()                                // 换行
    .showCursor();                            // 显示光标

🔤 输出与打印

• tc::tout：流式输出（支持颜色/样式/延时）
• tc::print(...) / tc::println(...)：多参数打印，支持颜色/样式宏

⏱️ 延时与等待

• tc::tsleep(ms) / tc::tsleep_stream << ms
• tc::wait(seconds)
• tc::waitKey()

📊 进度条

• tc::ProgressBar bar(width, doneChar, todoChar, color)
• bar.show(progress, msg)
• bar.finish()

🖥️ 系统相关API

• tc::getSystemTime(int type = SYS_TIMESTAMP)：获取当前时间（年、月、日、时、分、秒、Unix时间戳）
• tc::systemConsole(const char* 或 std::string)：执行系统命令
• tc::systemConsoleW(const wchar_t*)：执行系统命令（宽字符版本，仅Windows平台可用，支持Unicode命令）
• tc::systemCheck()：检测当前操作系统，返回操作系统代码
• tc::getOSName(int osCode)：根据操作系统代码返回操作系统名称
• tc::getOSVersionInfo()：获取当前操作系统的详细版本信息

支持的系统宏

用法示例

// 获取系统信息
int osCode = tc::systemCheck();
const char* osName = tc::getOSName(osCode);
std::string osVersionInfo = tc::getOSVersionInfo();

// 显示系统信息
tc::println("操作系统: ", osName);
tc::println("系统版本: ", osVersionInfo);

// 根据系统类型执行不同操作
switch (osCode) {
    case OS_WINDOWSNT11:
        tc::println("Windows 11系统特定操作");
        break;
    case OS_UBUNTU:
        tc::println("Ubuntu系统特定操作");
        break;
    case OS_MACOS:
        tc::println("macOS系统特定操作");
        break;
    // ... 其他系统 ...
    default:
        tc::println("未知系统操作");
}

⏱️ 获取系统时间

int year = tc::getSystemTime(SYS_YEAR);
int timestamp = tc::getSystemTime(); // Unix时间戳

⌨️ 按键处理

waitKey - 等待按键

• tc::waitKey()：等待任意按键
• tc::waitKey(char key) / tc::waitKey(int key)：等待特定按键（如 tc::waitKey('A')、tc::waitKey(KEY_ESC)）

tc::waitKey(); // 等待任意键
// 等待按下A键
tc::waitKey('A');
// 等待ESC键
tc::waitKey(KEY_ESC);

isKeyPressed - 检测按键状态

• tc::isKeyPressed(char key) / tc::isKeyPressed(int key)：检测指定按键是否被按下

// 检测ESC键是否被按下
if (tc::isKeyPressed(KEY_ESC)) {
    std::cout << "ESC键被按下" << std::endl;
}

// 检测方向键
if (tc::isKeyPressed(KEY_UP)) {
    std::cout << "上方向键被按下" << std::endl;
}

// 检测字母键
if (tc::isKeyPressed('A') || tc::isKeyPressed('a')) {
    std::cout << "A键被按下" << std::endl;
}

常用特殊按键宏

🛠️ 编译

• Windows: g++ -std=c++17 test.cpp -o test.exe
• Linux/macOS: g++ -std=c++17 -pthread test.cpp -o test

📄 协议

MIT

🌐 联系

• 📥 电子邮件：wushaoquan666@outlook.com

首先声明：我使用的是Dev-C++ IDE 5.11。这款软件属于IDE（集成开发环境），即自动配置了编辑器、编译器等，不需要输入传统的命令即可进行编译等操作。个人认为它比Visual Studio要简洁易用得多，不过只能编写C/C++的程序。

头文件

在C++程序中，头文件是基础组成部分。头文件声明了我们要使用的各种函数。

系统头文件使用尖括号<>，本地头文件使用双引号""。可以通过以下方式导入：

#include <iostream>    //已在环境变量中配置好，可以直接使用
#include "test.h"    //需要头文件的具体路径，支持绝对路径和相对路径

其中iostream是标准输入输出库，提供cin和cout功能。除此之外，还有许多库。

C语言头文件

• 后缀为.h（如windows.h）
• 可被C/C++使用

内容仅包含函数、常量声明等。如：

//test.h
#ifndef _TEST_H_    //避免重复包含
#define _TEST_H_
#endif

#include <string>
#define APP_NAME "YourAppName"    //定义软件名称
void functionName();    //声明函数（不包含定义）

C++头文件

• 无后缀（如iostream）或.hpp后缀
• 仅C++可用

内容即包含函数声明又包含函数定义，还支持更多C++特性，例如模板、命名空间等。如：

// Example.hpp  
#pragma once  //避免重复包含（也可以使用#ifndef）

#include <string>  

class Example {  
    public:  
        void print(const std::string& message);  
    private:  
        int count;  
};  

// 内联函数实现  
inline void Example::print(const std::string& message) {  
    std::cout << message << std::endl;  
}

命名空间

接下来是这段代码：

using namespace std;

这段代码声明要使用std这一命名空间，可写可不写，我用输出代码来举例： 写了：cout<<a; 不写：std::cout<<a;

命名空间的作用就是避免函数标识符冲突，如输出用的cout实际就被包含在std这个命名空间里，保证不会与其它同名函数冲突。

在面对大项目时，函数重名是常有的事，此时就建议不写using namespace，而是直接显式指定命名空间，如完整地写std::cout。不过在写小项目时，为了偷懒（方便）我们也可以写上这一大行的命名空间使用声明。

命名空间的创建往往在C++头文件中，这么写：

namespace YourNameSpaceName {    //声明并定义命名空间
   int yourVariable;    //变量
    void yourFunction() {    //函数
        // 代码实现
    }
}

主函数

主函数是程序入口，格式为：

int main(int argc, char* argv[]) {
    //这部分就是代码区域

    return 0;
}

所有C++程序都需要有主函数，即int main()。

可以看到主函数的括号当中还有int argc和char* argv[]，这是程序启动时的参数，也可以空着。第一个int类型的变量是一个整数，表示程序启动时的参数数量。第二个char类型的指代一个字符数组，即各个参数内容。

命令行示例：

程序文件名 参数一 参数二

此时argc=3，因为有3个参数，其中第一个参数argv[0]是你的程序文件名，argv[1]是参数一，参数二同理。

很多命令行程序通过启动参数，来完成任务，极大地方便了命令行用户的操作，例如：

cp test.txt ./test/target.txt

cp是类Unix系统里的复制程序，命令功能是将test.txt复制到./test/target.txt的位置。我们在开发时可以通过用户提供的参数让程序进行对应操作。

如果你要写Win32程序，那么恭喜你，你的主函数长这样：

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);

个人评价是巨硬挺抽象的（

return 0;表示程序正常退出。控制台程序通常要明确终止点。

这就是刚刚所编的所有代码。

这就是运行结果，是空的。下方的“---”、“Process exited……”和“请按任意键继续”不用管它，这是集成开发环境加上的，实际单独运行就不会显示。

输入输出

在C++中，可以使用cin和cout实现基本的输入输出功能。cin用于接收用户输入，cout用于输出结果。同时，C风格的scanf和printf也可用于类似功能。

数据类型的选择

C++提供了多种数据类型用于存储不同类型的数据。常见的数据类型包括：

• int：存储整数
• char：存储单个字符
• string：存储字符串
• float：存储单精度浮点数
• double：存储双精度浮点数

选择合适的数据类型是程序设计的关键步骤。若数据类型与输入内容不匹配，可能导致意外结果。例如，若程序预期输入整数但用户输入字符，输出的可能是字符的ASCII值而非预期数值。

示例

#include <iostream>
using namespace std;
int main() {
    int a;    //声明变量
    cin>>a; //输入
    cout<<a; //输出
    return 0;
}

该程序中，变量a为int类型，仅能存储整数。若用户输入浮点数如1.1，程序仅会存储整数部分1。

当然，在声明时也可以赋值：int a=0;这样它的初始值就是0。这时候我们删去输入的部分，就会输出0。 int类型还有一个特点，它是32位的，其中内存中的第一位是正负位（0表示正数，1表示负数），所以它的数据范围是2的正负31次方（-2147483648 ~ 2147483647）的整数，所以在任何时候都不要超出或小于这个范围，超出或小于，编程术语为“溢出”，可能引发程序错误，在早期不够成熟的应用程序中都容易发生这种情况。

下面是专门接收字符的：

#include <iostream>
using namespace std;
int main() {
    char n[10001]={};
    cin>>n;
    cout<<n[0]<<" "<<n[1];
    return 0;
}

字符数组声明时需指定大小，通常为最大字符数加1。初始化时建议使用= {}以清空该内存区域。输出字符数组时需通过下标访问，下标从0开始。例如n[0]表示第一个字符，n[1]表示第二个字符。

热情碧血燃星火，寒枝冰心何由彻？

万叠征衣凝夜紫，一襟风骨立苍茫。

此身若许红旗卷，不共青山论短长！

呜呼哀哉，这就是“怀才不遇”的感受吗？

创作于 2025年5月16日

这是一篇博客测试。

我未来打算在这个网站上发布一些干货文章，敬请期待。

每个长期项目，都从一个简单的 Hello, world! 开始。

下面是无序列表测试：

• 第一句。
• 第二句。
• 第三句，酷吧。

除此之外，也可以在文章里放置图片、链接和其他内容。