Hello! on Mao's Blog

明天还是有雨

Sat, 20 Jun 2026 22:00:00 +0800

2026年06月20日

“嫌弃下雨的天气，可怜垮掉的发型。新买的鞋子沾上泥，金鱼在袜子里嬉戏。”

下了多久的雨？我不记得，只知道每天醒来就感觉衣服黏在身上，睡前抱着被子，也是腻腻的。我的皮肤不好，碰到这种天气，下巴和脖子上都长了不少疹子，摸上去的手感糙糙的，又黏黏的，像是在摸癞蛤蟆的皮。

晾不干的衣服，又潮又沉的空气，连带着人的一举一动，都增加了许多阻力，仿佛真的在水中一样，却又缺少游泳时的畅快和清凉。说真的，再在这种天气里多待几天，人类应该就能进化出鳃了吧。

说真的，“沾衣欲湿杏花雨”，也得是春日漫步之时，闲情逸致之中下起的细雨才动人，而当人本身就一肚子烦闷，雨又一直将落未落，悬在半空，湿湿答答，黏黏腻腻，从四面八方附上来包围你的时候，这样的“沾衣欲湿”只会让人产生暗暗的烦躁和期待吧。烦躁的是，雨怎么还没停；期待的是，雨应该会停吧？其实也不是雨让我烦，只是下雨把我和我的烦闷一起关在这间寝室里，谁也出不去。说实在的，这场雨已经下了太久，久到我已经分不清我是在期待着天晴，还是期待着别的什么。

这种期待，落到行动上，就是每天早上第一件事，看看天气预报，然后走到阳台，把手伸出窗外，感受指尖是否有凉凉的触感。就算一时没有下雨，看到阴郁的天色，出门最好还是要带伞，所谓“未雨绸缪”，我到今天才知道“未雨”是什么感觉——它在头顶一直一直悬着，你不知道它何时会落下来。

昨天和朋友外出吃饭，初时还没下雨，本打算去天街，而一出门就飘起了雨花，随后便淅淅沥沥起来，于是只能转战他处，从骑车转为打伞步行。而走在路上，就算有伞，飘荡的雨滴也会打湿半条裤腿，地面上不仅有一眼望去便让人生畏的大水坑，还有暗藏危机的地砖，一旦踩上去，鞋袜就湿透了。

雨会停吗？这个问题其实问得没有必要，因为，所有的雨，最后都是会停的。那为什么还要问这个问题呢？其实我们想问的是：“现在，雨会停吗？”当你在寝室枯坐一天，不发一言，偶尔扭头望向窗外的时候，心里应该也在期待，窗外的是金色的暖阳，而不是剪不断的潮气和雨滴吧。

写到这里，雨已经停了，但外边的天还是阴沉沉的，而我盯久了屏幕的双眼，看不见一颗星星。

天气预报说，明天还是有雨，后天和大后天也是。

为什么我不喜欢CS3321数据库技术？

Fri, 19 Jun 2026 22:00:00 +0800

2026年06月19日

声明：本人对授课老师的教学态度和教学水平没有任何意见，仅对课程本身的内容设置做一定思考和点评。

复习了前四章，还有八章没有复习，但已经没什么动力继续了……为什么这么说？因为这门课的内容，实在是太多了！

如你所见，这是一门数据库相关的课程，总共有十二章，几乎每一章的 PPT 页数都超过 100 页，最多的应该能有 200 多页。老师在课上不止一次说过，希望能给同学们带来数据库的全面了解，并且这些 PPT 也是用心做的，老师自己配了很多图，帮助大家理解；甚至，听到有同学在座谈会上反馈 PPT 内容太多之后，老师似乎还有点委屈。

课件内容丰富，老师上课态度认真，这本应该是好事，但从大家的学习体验来说，这确实不是一件好事，为什么？这个问题的答案是另一个问题：这门课，到底想教会我们什么？

我个人会笼统地将这门课的内容分成四个部分：

数学知识，比如关系代数，以及相关的集合论知识
SQL 语言与数据库编程的各种语法细节
数据库系统设计的相关内容
在每个主线内容之外，其他一些偏“背诵”性质的内容

所以，老师大概试图教会我们下面这些内容：

数据库的底层数学原理是什么？怎么从数学的角度去理解数据库？怎么证明数据库的正确性？
SQL 编程里面的增删改查的各种细节语法。
如何从零开始设计一个数据库系统？数据库系统是怎么做存储管理、查询优化、并发控制的？

老话说，样样通，样样松。但老师不愿意我们这样，所以确实在每一个部分都讲解了大量的内容。可这样做，无疑加大了学生的学习负担。而且，老师所讲解的大量内容，并不一定就是学生需要的，更多的是在主线之外，所增加的需要“背诵”的内容。比如，我们真的有必要像了解 SQL 编程的那么多语法细节吗？真的需要花这么多页 PPT，一个语法一个语法讲解过去吗？就算为了考试，一时能记下来，过后必然也会忘记，那么学习这些的意义是什么？

就我个人经验而言，这样“大水漫灌”的授课方式，让我很难听进去课，我尝试听过几节课，但很快就放弃。而且，就我个人观察，每节课真的在认真听课的同学，通常不超过三个。我想，主要是我不知道这门课到底想要教会我们什么：好像什么都想教会，但最后却什么都教不会，最后留下的，只有考前一页页过 PPT 时，那种无奈和暗暗的愤懑。

我学习过 CMU 的数据库课程，同样是量大管饱，但那门课确实能做到有一条明确的主线，就是如何动手实践，编程设计一个数据库内核，学以致用。相比之下，IEEE-CS 的这门《数据库技术》，还是差了点意思。

诚然，老师授课态度确实很认真，但老师更像是一位高中老师，其所反复强调的，无非“上课是否认真听”以及“考试会不会做题”。而事实上，对于一个大三下的学生，这两件事情早就已经无足轻重了。有想学的内容，如果学校不教，那么大家会自己去学。而如果一门课并不是自己所希望学习的，也并不能学到太多深刻的东西，同时负担还很大，只是为了“通过考试，拿一个还不错的分数”的话，那么我想不到同学们会有什么学习的热情，也无怪乎大家不喜欢这门课程了。

成长是逐渐摆脱自恋的过程

Wed, 17 Jun 2026 22:00:00 +0800

2026 年 06 月 17 日

我现在认为，长大是一个逐渐摆脱自恋的过程。

需要说明这里“自恋”的含义：不仅仅是说“觉得自己很厉害”，去做一些想要引起他人注意的事情，也包括“觉得自己这么做不对”，每次都在多想，想着“自己这么做别人会怎么看自己”。也就是说，“自恋”是把事情的中心、关注的焦点始终放在自己身上，而不是事情本身或者社交的人身上。

拿我自己举例子。比如，害怕面试，不是真的害怕面试，而是害怕“面试没通过，让我觉得自己不行”这个感觉。再比如，不敢主动约别人吃饭，不是真的不想和别人一起吃饭聊天，而是害怕“被别人拒绝让我觉得自己不好”这样的想法。

怎么说呢，“自恋”其实是把自己放在了“被审视的客体”的位置，这好像和“自恋”这个词本身的含义矛盾，实则不然。因为，“自恋”就是在用外部的视角去看自己，而不是真的用心去体会自己的感受。再举几个例子：我想发展一个新的爱好，我想的不是“这个爱好是不是让我感觉开心”，而是“这个爱好能不能让我看上去很酷很厉害”；我分享一条朋友圈，我想的不是“这条朋友圈有没有真实表达我当下的感受”。而是“别人看到这条朋友圈，会怎么想我”。

也就是说，自恋的人，不论做什么事情，其关注点始终在自己身上，事情只是他评价自己的一个外部因素而已，不是他真正追求的。倒不是说这样的“自恋想法”有什么错，只是有时候，这种观念会和现实情况不匹配。我有这样一种看法：自恋的人，往往有段时间会觉得自己“无所不能”，有一种不知所谓的“全能感”，希望自己做到最好，去证明自己的特殊性，或者存在的意义；受到一些打击之后，又会感觉自己什么都不行，用一种外在的视角去批判自己，否定自己，最终恐惧展示自己，恐惧被审视。这样，自恋马上就转化为自卑了。

或者说，自恋其实本就是自卑的一种特殊形式，两者同本同源。唯有当缺乏完全的自我认同时，才会需要他者的评价，来确立自身价值的锚点。还是拿我自己举例子，小时候，我非常喜欢表现自己，喜欢让别人觉得自己很厉害，其实是我内心不太确定自己是不是真的厉害，所以需要别人的夸奖；而在中学时代被老师责骂过几次，说“表现自己是不对的”之后，我就缩在自己的壳里不敢动弹了。当然，这样的转变不止和我中学时代的经历有关，“价值=表现”的因果，可能在某个不经意的瞬间已经种下。回到“自恋”的话题吧，就像现在网络流行语“嘉豪”一样，这些行为是“论心不论迹”的。当我意识到自己以前有多么自恋，有多么“嘉豪”，现在就有多么自卑，有多么怯懦。

我真的很希望，自己有一天做事情，不是从自恋的、外部评价的视角出发，而是从心出发，从自己真实的感受出发。这很难，很需要勇气，但如果要成长，这是必须的、无可替代的一步，只能自己去走。

总有人坚定，总有人相信

Fri, 12 Jun 2026 22:00:00 +0800

2026年06月12日昨晚我爸妈先回了台州，而我又在酒店住了一晚，今天上午回上海。本来说好是我哥送我到丽水站，但在酒店门口，车窗降下之后，驾驶位上的却是嫂子。

我正纳闷着，上车一看，原来我哥正放倒了椅子，躺在副驾驶位置上，看着有些不省人事，嫂子面色也有一些疲惫。我一问嫂子，她只是笑着说道：“你哥昨晚喝多了，一直吐在枕头上，吐到两点，我一直在帮他收拾，所以昨天我们都睡得比较晚。”堂哥哼唧了几声，算是在说“我没意见”。

我本想接着问，但从后视镜里看到嫂子略显疲惫的脸，话又咽了回去，于是车里安静下来。我看着窗外掠过的山景，想起昨晚宴席的感受。

其实平心而论，昨天的订婚宴对我来说，还是太折磨了，光是站在一堆不认识的人中间，我就感觉无所适从，好像没穿衣服一样：不知道手该往哪放，话要怎么说，只能像个木偶一样，有人说话就举杯，接着微笑点头。而对于我哥，订婚宴的主角之一，需要挨个桌走过去，一直喝酒一直敬酒，一直说话。我光是想一下这个场景，感觉自己就要晕倒了。

我和我妈说了我的看法，她说：“你现在觉得累，但是如果是陪着你心爱的人一起，那肯定不会这么累的呀。”我却说找到心爱的人并非易事，两个人相互喜欢更是难上加难。而且，就算两个人相互喜欢，也要经过重重考验，最后才能修成正果，走向婚姻——但是那一天之后呢？公主王子在一起之后，故事就结尾了吗？并非如此，后面还有大段的、空旷的人生有待体验，这种空旷，让我有些害怕。

我也有想过，自己的婚礼会是什么样的。我的幻想很多，我喜欢在生活里找到一些象征，甚至把这些象征作为宿命的证据，但事实上，象征是危险的，所有的宿命都只是巧合。我听了太多了情歌，有过太多幻想，曾经因为一首歌想要办一场婚礼，想要把这首歌作为婚礼的尾奏，除了那个画面之外，我想不到任何其他的规划——在什么地方、请哪些人、穿什么衣服、说什么话……这些太具体了，太不“象征”和“宿命”了。

怀着这样的困惑，以及一点点八卦的心情，昨天和我哥见面时，我便悄悄问他和嫂子是怎么认识的，他只说是“大学同学”，自然而然就认识了。后面两位新人一直忙着拍照、招待客人，还有走一些我不懂但十分复杂的流程，于是我便没有追问。正好，今天送我回来，只有哥嫂加我这个“灯泡”，于是我接着昨天的问题，直接去问了嫂子：“昨天我问我哥，他说你们是大学同学来着，我想问你们是谁追的谁啊？”

嫂子伸伸手指着还在闭目养神（实则还没睡醒）的堂哥，说“是你哥追的我”。我就继续问是咋追的呀，她说：“就是有段时间，你哥突然就 QQ 上一直找我聊天，哦，可能那个时候疫情吧，你哥也比较‘寂寞’。”说着说着，嫂子就开始笑起来了，又用手轻拍我哥的大腿，问“对吧对吧，是这样吧”。

我哥的头从座椅一侧晃到了另一侧，半梦半醒之间，点点头，说了一声是。我就继续追问：“所以我哥后来就来丽水找你玩了？然后就在一起了？”嫂子便继续说道：“呃，其实也不是，因为那时候我感觉突然来找我玩有点奇怪，是后来先在确定了关系之后，他再来丽水找我的。”

“原来是网恋奔现啊！”我脱口而出。说完，嫂子和我都哈哈大笑，我哥在旁边也有点醒酒了，跟着一起笑起来。

“对，差不多就是这样。”嫂子一边伸手点了点手机上的导航，一边继续说道，“正常的应该是先见面约会几次，之后再在一起的吧？（我说，对的对的）但当时不知道为什么，反正就莫名其妙先在一起了。”

真是一件好玩的事情！原来他们是这么认识的——这么莫名其妙在一起了。

车里又安静下来，于是我再看向车窗外，山和之前有些不一样了，脑海里也莫名响起那首歌，那首让我想要办一场婚礼的情歌。

这首歌是方大同的《好不容易》，很爱的一首歌里最喜欢的一段词，送给各位：

总有人坚定总有人相信总有人懂得爱能深刻无底 …… 我在这里待着你，很值得一直我会爱着你心服的，心不舍一切都不可思议因为爱的只有你我已换了自己我意识到，好不容易，好不容易好不容易，爱到你

除夕火

Thu, 11 Jun 2026 22:00:00 +0800

序：本文是三年多前的旧作，现在看来，十七岁的毛大，文笔还是十分青涩，但也真实可爱。感谢当时的自己，记录下一个难忘的夜晚。

为什么想到旧作重发？今天到嫂子娘家的老房子，一样的木质结构，一样的老而不朽，让我一下子想起当年在火中消逝的老屋。之后，全家人一起爬山，奶奶八十多岁，但身体仍然硬朗，步履稳健。想到四年过去，老屋已经修缮一新，甚至旁边新建起一所小学，奶奶依然身体安康，堂哥订婚，将迈入人生的新阶段，爸妈的工作也比以前更有起色，不再时时为钱而唉声叹气。而我从高三走到大三，从温州到上海，从小孩渐渐变成大孩，迷茫不减，步履不停。

在原文的结尾，我说“这是一个关于失去的故事”，现在我想，不止如此。

序就此结束，以下是原文。

除夕，年夜饭在二伯家吃。

四点半一家人出门，去老屋接奶奶。我出门时顺手从书架上拿了一本《我与地坛》，打算无聊时看。

老屋在下里河畔，这里路不宽，难容两车并行。在这儿，奶奶住了一辈子了。爷爷是从宁溪离家来到路桥讨生活的，在这无亲无故，白手起家。后来与奶奶成了婚，两人就造了一两层木房，定居在这河边。他们有四个孩子，都是男孩。老大在事故中英年早逝，也没留下子嗣。余下三人便是大伯、二伯和父亲。三十多年前，下里河的水还是清的，可以游泳，或是捉点小鱼小虾当点心。大伯二伯年岁大，懂事也早，只有父亲最顽皮，常常翘课去外边野玩。这时，奶奶总会大声叫骂着，把父亲拉回小学去——就在老屋的隔壁。三十多年了，爷爷因卒中而逝，三个兄弟各自成家离去，下里河的水也早已混浊发绿，不知道还有没有顽强的鱼虾存活着，而隔壁的小学也废弃了，只留下褪色的字与满地的垃圾。这十几年，只有奶奶一人住在老屋。

路不远，车很快到了老屋门口。屋前有一小片空地，因此车向着空地停下后，勉强能容其他小车开过。稍大的车，都开不进这条古老而狭窄的路。

父亲下车去，进了老屋，母亲和我则在车上等候。无事可做的我看起了书。时近黄昏，天色阴沉，我看得颇为费力，因此看了不久便有些不耐。母亲也是，抱怨道：“你奶奶就是很慢的，每次来，东弄弄西弄弄，都要搞好久。”于是我下车，进屋去看看。屋内很暗，却有什么东西在熠熠生辉——那是观音像前的烛火，燃的很旺，连带着旁边纸箱里的元宝也反射着金光。说是金元宝，其实只是金色纸折成的罢了。奶奶信佛，逢年过节都要去庙里烧香送元宝，闲时也准备些。再向前看，黑暗里正是奶奶枯瘦的身影。

“奶奶，快些！”我催促道。

“马上马上！我手机哪去了？手机不带着，晚上有人找我怎么办？”说着，奶奶又向屋内走去，蹒跚着脚步。

“谁会找你啊？你现在是大忙人啊，晚上不带手机大家都找不到你！”父亲急了，他也被自己磨蹭的老母弄得有些不耐了。

“别催我别催我，马上就好！” 过了几分钟，我们终于从老屋出发了。我回头看了一眼，暮色里，对岸的医院大楼灯火通明，而老屋在寒风中，显得苍白无助。

“明天我要去拜佛，自己走路去！”奶奶兴高采烈。她七十多岁了，身子骨倒也还硬朗。庙里有些活动，她每每都走好多山路，亲自前往。

“挺好，挺好。”我能听出这是父亲的敷衍。奶奶年纪大了，总爱絮叨一些小事，因此父亲听多了也就不太关心了。

不久，就到了二伯家。大伯家早就到了，几家人拉着家常，等着开饭。我一进厨房，便是一阵预料中的寒暄。

“天天啊，长高了好多啊，现在和门一样高了！” “好长时间没见过了，读书多辛苦啊，都读瘦了！” “要不要先吃点啊，其他菜马上就好！” ……

其实我根本没长高，读书虽然辛苦，但也不会让我瘦到哪里去。可我还是喜欢这样的寒暄：亲切、热情，让我感到温暖，但同时也有点手足无措。慌忙应付了一阵，我便跑到客厅，自看自的《我与地坛》去了。

外边的炮仗一直响着，不时有绚丽的烟火透过窗，一闪一闪。似乎没有这些喧闹与光亮，年便不是年了。在这炮仗声中，我好不容易逐渐沉浸在书中，却听见楼上二伯扯着沙哑的嗓子大喊： “什么？老屋着火了？好，好，我马上就到！”

紧接着就是一阵急促的脚步声与慌张的叫喊声，二伯、父亲、大伯三人先后冲出了屋子，奶奶踉跄着跑在后面，喊着“带我也去”，却没能跟上。她回身，上楼拿了些东西，嘴里念叨着“阿弥陀佛，阿弥陀佛”，已是带着哭腔——老屋就是她的全部，她祈祷着，希望日日虔诚供奉的佛祖这一次能保佑她。

堂哥闻讯下了楼来，说他开车带奶奶去，母亲和大伯母也跟着一道去了。原本热热闹闹的年夜饭，瞬间便只剩下二伯母、堂姐和我。对这场除夕大火，堂姐比较乐观。

“奶奶那个老屋啊，反正烧都已经烧了，她哭也没用。这火一烧啊，明年我们就红红火火，要发大财嘞！”堂姐笑道。

但愿如此吧。

我能感受到，老屋之于老人，不止是一间破旧的木屋。

我继续看书，等着其他人回来，一起吃饭。

不知过了多久，饭菜已经凉了七七八八，终于听到了门开的声音，以及奶奶呜咽的哭声： “我的屋啊，我的屋！没了，都没了！”

土话里，我们不喜欢说“房”，而更多用“屋”来指房子。很快，“屋”声与呜咽声就混在一起，难以分辨了。奶奶完全是一副生无可恋的样子，上了楼后，驮着背垮着脸，坐在椅子上，无论三个儿子怎样劝，愣是一口饭不吃，像个小女孩一样赌气。

“反正火已经烧完了，我今天晚上就要住回去！” “老娘啊，你怎么就不听讲呢！今天晚上警察管到天亮，谁都不让进的！” “那明天呢？” “明天要调查从哪儿烧起来的。你老屋已经烧了个精光，旁边的旧学校也烧了好几间房，以后老屋可能都住不了咯。” “那我就去住佛堂里！” “佛堂？你想出家当尼姑啊？我们三个儿子反正都有屋住，你想住谁家住谁家，没啥好哭的啊。要是我们都没屋，你都没地方住，那不光你哭，我们也该哭了。”

闻言，大家都笑了，除了奶奶。她还是气鼓鼓的，旁边二伯母已经盛好一碗饭，放在奶奶的面前。

窗外的鞭炮仍在响着，噼里啪啦。

“哎呀，老娘你就别老在忖这个啦！我们这个老屋，就当烧给老爸了，你那些东西啊，先在老爸那里存着，过了十几年你去拿不就好了？正好你折的那些元宝，都帮你烧给佛祖了。” 这是父亲不算安慰的安慰。

其他人也是七嘴八舌地劝慰老人，奶奶也知道，她不能一时意气用事而气坏了身子，多少也都吃了点。这是电话响了，是奶奶的闺蜜打来的： “喂，阿青啊，我是芳。我跟你讲啊，我……我的老屋烧莫了，什么都没了……” 她哽住了。

我从视频里看到了那场熊熊大火：火光冲天，浓烟四散，夜色中红得骇人，将天空撕裂出一道血流不止的伤口。万家灯光温暖，一处烈火惊心。消防车开不进那狭窄的路，灭火费了好一番功夫，而木质的老屋，被烧得面目全非。

万幸的是，人没事；不幸的是，过去的所有被葬送在除夕火中。老屋已一片焦黑，记忆中的温存又该寄托何处？

这是一个关于失去的故事。

毛天宇壬寅年腊月三十

一棵树在森林倒下

Thu, 04 Jun 2026 22:00:00 +0800

2026年06月04日

无聊的时候，我喜欢练字。这是高中时就坚持过两年的习惯，最近又拾了起来，但感受完全不同。今天写完，我放下笔，看着纸上的整整齐齐的一笔一划，明明是我亲手创造了它们，却又有点陌生，好像什么都没做。就像，一棵树在森林里倒下，你听见了树倒下的声音，但你没有把握，那声音是真的，你想问问其他人，却发现只有自己。

我拿起笔，又在纸上划了一道，却没有继续写的欲望，然后我把笔放下了。反正，不知道从什么时候开始，不论是科研、学习、跑步还是练字，在做之前总是有种“好没意思”的声音在心中回响。看着宿舍凌乱而熟悉的桌面，已经摸了无数次的键盘，月历一页页翻过（我真的有个星露谷的月历），一成不变的日子，醒来又睡去，睡去又醒来，我不可避免地开始思考，我究竟在做什么？

中午的寝室好安静，室友们都在休息，我也打不起精神，便翻身上床睡觉。遇到困难睡大觉曾经是个妙招，但现在却怎么也静不下心。翻来覆去，想到一个说法：人生的体验不是线性的，而是类似对数的，所以在二十岁，你人生的一半就差不多过完了；剩下日子的体验越发匮乏，人生的时钟越走越快，最后，在某一个瞬间，嘀嗒声戛然而止。

这种说法让我感到恐惧，无穷的恐惧。其实这种恐惧，所有人都不陌生：当人意识到自己终究会死去的那一刻，恐惧和怀疑的种子就在生命中扎下根来。二十岁的我，不该如此暮气沉沉，却仍然因为“可感的人生已经过去一半”而悲伤——我的可能性，已经在不断地减少了。

是的，人生的可能性——我想说的就是这件事。每当做出一种选择（或者，被做出一种选择），就同时也意味着一种可能性的消逝。我无法接受这种消逝。我想，能被看见，能被记住，是否就可以应对这样的消逝了呢？回想这两年以来，甚至上大学以来，真正让我感到有意义的时刻，到底有多少呢？其实并没有很多。

睡不着，翻了个身，看到手机锁屏上的 6 月 4 日，发现过两天便要高考，于是又开始追忆当年的自己。中学时代的快乐很简单，有一种不经思考的纯粹，只需要考高分，就能被记住。但大学并不是这样，首先你不一定能考高分，其次考高分这件事情，本身的意义就在被不断削弱。

我躺了一会，最终还是下了床来，打开台灯，对着纸上的字迹发呆。上大学之后，让我感到满足或者有意义的瞬间有什么呢？来自分数或者奖学金？那些都是优绩主义，而且成绩单在你离开学校之后就是一张废纸，毫无意义；来自科研的吗？科研更是一滩烂泥，我无法想象自己真的能做出什么创新的东西来；来自某些爱好？爱好真的存在吗？我没有心力去培养一门爱好，也从来没有那种因为一件事情做得很好而非常满足的体验。或许还是有一些让我感到满意的时候，比如我很喜欢整理笔记，之前因为分享的笔记非常好而被同学感谢过，或者说，当我写出满意的作品，收到一些评论和反馈时，我内心也很满足——可这还是“被看见”的一环。

寝室还是好安静，安静得只能听到室友的呼吸声，和我敲击键盘的嗒嗒声。不得不承认，前二十年的人生，我的经历和我受到的教育就是在告诉我，外部的评价就是一切，所有的幸福和满足都来自于比较，都来自于“被看见”的某一个瞬间。当你不再相信“优绩主义”，不再想“卷”，没有能力也不再愿意通过成绩去证明自己，你想说“人生是旷野”，但这旷野上八面来风，却吹得你晕头转向。这时候，你到底是什么？你还能被看见吗？

我站了起来，揉了揉有些酸痛的腰。如果不能被看见，我真的还能找到继续前行的动力吗？还是说，单纯就是我过于矫情，我爸妈就会说，管他那么多，把自己手头上的事情做好就行了。可是我必须要想清楚一些事情，才能去行动；还是说，我只是在用这些，来逃避？或许，在行动中，意义会自然生长，可我真的能坚持到意义生长出的那一天吗？

一棵树在森林里倒下，你听见了树倒下的声音。你仍然不确定这声音是真的，但或许你也不必去问谁，你可以自己去看看。

从南大门到庙门

Tue, 02 Jun 2026 22:00:00 +0800

2026年06月02日

南大门是我进出最多的门。每次离开学校，或者从什么地方回到学校，我都习惯于坐地铁，总是从南大门进出。这个学期，思源门不让校外车辆进出，于是打车时我也只能走南大门了。

我还记得第一次走进南大门的场景，并不是入学时，而是大学里第一个国庆假期，在杭州和高中的朋友聚会完，在虾龙圩站的 C 口拍了合照，一起坐到杭州东站，然后分道扬镳。只有我一个在交大，在闵行，所以我一个人回来。

那时候我也还不会用地图软件直接定位到宿舍楼，坐到紫竹高新区已是晚上十点多，手机也几乎没电。第一次走进南大门，我觉得南大门好气派，学校好大好大，我被抛到一个完全陌生的世界里，不知道该往哪走。我记得，当时我先向北，一直走到了主图所在的那条路（应该是宣怀大道和文治大道中的一条？），然后再向西走，最后向南，从学森路终于绕回了宿舍楼。一看手机，刚好十一点，电量见底，安全抵达。

后来在学校里走多了，学校便越变越小，而当我知道从南大门回宿舍，只需要沿着南洋南路一直向西走之后，我便再也回不到那个觉得学校好大的深夜了。来来往往，宿舍到南大门这条路走多了，便不觉有什么可惊叹的。两年的时间里，这条路也从一开始的全是施工围挡，只有靠北的小道可走，到后来慢慢开放，而大路也是终于可以走了。

这时候，这条路又变得有些不同。从前，我只是骑到从南大门，便转向离开学校；而大路一开，在骑车之余，有时便抬头望向远处，我会想：“南大门的东边，是什么？”

有一个简单的回答，一抬头便能看见——华东师范大学。这让我联想到水源神帖《庙门使用手册》的楼主和他的华师大女朋友（们？）。原帖非常精彩，这里附上一段：

“然后收起手机，上车继续奔袭，再过两分钟就驶过了图书馆、行政楼，前面不远就是庙门，我看着它越来越近，我想起谭学长说的话，‘要勇敢，只要过去，你就能获得幸福！’，庙门也看着我，扒开大嘴，迫不及待吃我下去。”

所以说，南大门的东边，是华师大，而交大和华师大之间，大约还有一个庙门。不过，我当时从没主动去过，只有很久以前军训拉练时迷迷糊糊路过一次，所以知道答案之后，也没有特意去过。

和那位富有激情的学长不同，庙门是我进出最少的门，甚至路过都很少——直到我有一次出去骑车散心。那时，我刚骑到南大门，心里却想：要不再往东走一段？于是，我就一路向东，骑过南大门旁那几个从没记住名字的学院楼，骑过已经死去的密院，骑过从不会去的文博楼，在夜色中终于发现一抹红色——原来庙门一直在这儿。

自此之后，从南大门到庙门的这一段，成了我骑车最喜欢的一段路：人少，车也少，不必顾忌什么，也不必烦恼什么。我享受戴上耳机，一边骑车，一边纵情高歌，这比我在 KTV 里放得开多了，也舒爽多了。而从庙门到主图的那一段，则成了我跑步最喜欢的一段路：四下寂静无人，头顶夜色深深，道旁路灯灿灿，眼前路仿佛一直延伸，没有尽头，可以让我一直跑下去。

今夜又经南大门而至庙门，南大门还是那样气派肃穆，庙门，却似乎更雅致了一些。

执念如谜

Fri, 29 May 2026 22:00:00 +0800

2026年05月29日

中学时代，阴差阳错之下和一位同学合租。他是个重度许嵩迷，每天都要听许嵩的歌，许嵩出新歌的时候还要借我的手机来听。现在回想起来，当时在那个小小的出租屋里，天天回响着的有《雨幕》《雅俗共赏》《温泉》，而我后来又认识了一位同样喜欢许嵩的同学，因情事交流而结缘，他为我推荐了《幻听》，自此我开始听许嵩。《最佳歌手》是我高中时听最多的单曲。

初中时候，分班考之后还要继续留校补课，但大家都已经很松下来，无心学习，班主任便给全班所有人都买了《天龙八部》来打发时间。这是我看的第二部金庸的武侠小说（第一部是《射雕英雄传》），也是我看得最多、最认真的一本武侠小说，并可以说对我的人生观产生了莫大的影响。

《天龙》里面，有三位主角：段誉、萧峰、虚竹。我最钦佩和敬仰的是萧峰，经典的悲情英雄：爱而不得，遭人诬陷，壮志未酬，以死明志。但我最喜欢，也受到其影响最深的，却是天真烂漫的段誉。

段誉何许人也？大理国的皇子，武林世家，不懂武功却喜爱读书，还是个情种。他一举一动皆随本心，却守君子之礼，倾慕王语嫣，一直爱，一直不得，一直纠缠。在初版中，金庸安排他和王语嫣终于修成正果，这无疑是个美好的结局，却不太真实。所以，在后面的版本中，段誉最终想明白了自己对王语嫣的执念，然后放下了执着。段誉的这个心态变化，给当时的我造成了很大的震撼：爱可能不是真的爱，只是一种执念。

就算明白这一点又怎么样呢？我还是会被那快意恩仇的江湖所打动，喜欢那些有感人至深的爱恨纠葛。我也渴望自己能脱出现在这样平淡的日常，去冒险，去做一个大侠，去用最大的声音说爱、说恨、说我是谁，而不是当一个无趣的大人，每天压抑着自己的感情，去做自己不喜欢的事情。

许嵩其实写过六首和天龙八部相关的曲子：《半城烟沙》《天龙八部之宿敌》《雨幕》《放肆》《曼陀山庄》《如谜》。在我中学时代，金庸的《天龙八部》和许嵩的歌曲，都对我人生观与感情观影响深远。事实上，后者将前者，用词和曲更加浪漫化了。比如，《如谜》里面有几句我非常喜欢的词：

你是刀光剑影搅动我汹涌回忆人世前路如谜只愿能与君偕行

还有《天龙八部之宿敌》里的：

当天上星河转，我命已定盘待绝笔墨痕干，宿敌已来犯我借你的孤单，今生恐怕难还

当初青涩的我，很喜欢以段誉自况，既希望自己能落入枯井，真正有一个梦中的好结局，也希望自己终于洒脱，迈步向前。但其实，前者不可能做到，后者我暂时不想做到。毕竟，我不是段誉，生活也不是武侠小说，

我喜欢歌词里这样宿命式的相遇，以及悲剧式的结尾。我也相信当时那个在出租屋里听着许嵩、做着大侠梦的我，还有一部分在我的身体里，仍然存在。

前世劫与今生缘

Thu, 28 May 2026 22:00:00 +0800

2026年05月28日

早上和我妈聊过一场，聊着聊着我又落泪。我妈表示完全不能理解我的悲伤：明明还没开始，明明相处很短，有什么好这样落泪难过的。接着又问起：你高中时候被那个喜欢的女生拒绝的时候，也这么难受吗？

我说，是的，而且当时难受了快一年多，才慢慢走出来。我妈震惊无比，笑道“你还真是个多情种子”。我妈说，错过了，就说明你们缘分尽了，到此为止，这就该放下了，又有什么好悲伤的呢？我说，正是因为感觉缘分就到此为止，所以我才难以接受。

接着便陷入了一阵无言中，唯有我断续的啜泣声，以及抽纸时簌簌的响动。就在我刚以为我妈真的无言以对时，她缓缓开口：

“我听你爸说过，今生的夫妻，都是前世给你下葬的那个人。你倒在路边，有人可能给你盖了一条草席，有人可能给你上了一炷香，有人可能停下来为你祷告，他们在今生可能会陪你走一段路，会和你擦肩而过，但不会陪你走到最后。只有一个人，他/她安葬了你，让你入土为安，所以你们今生才有夫妻的缘分。”

“也可以换个说法，在你看来现在他/她无意之中给你带来了伤害，你很痛苦，那可能是前世你伤害了他/她，前世你们有一劫，在今生便成了缘，但有缘无分，所以他/她给了你希望，陪你走了一段，最后还是转身离开，这一劫便已报了。”

“所以，在别人转身离开的时候，你们之间的缘已尽，痛苦也该结束了，而不是被你独自背负着。你该每天扔掉一点痛苦，然后继续走下去，等着真正的缘分到来。”

我以前是从来不信什么前世今生的，但我妈絮叨了两个多小时，唯有这段话给了我莫大的震撼与安慰：前世的劫，却变作今生的缘；前世被你伤害的人，今生无意间伤害了你；前世为你下葬的人，今生也会如约而至，在你命中出现，无人可免。

这样的玄学与宿命让我安心，哪怕只是今天。

有家可回真好

Wed, 27 May 2026 22:00:00 +0800

2026 年 05 月 27 日

什么时候算是回家了呢？是在走上动车之后，发现前后左右皆是乡音？还是听到老妈熟悉却温暖的唠叨，吃到老爸做好的家常菜？看着街景在车窗外一幕幕闪过，我不禁有些恍惚——三个月前才离开，却仿佛过了好久。

每次回家，对门的狗总要冲我狂吠，因为我回来太少了，在它眼里是个过客。所以，对我而言，这也是一种回家的标志吧。

当我进屋，外面立刻风雷大作、雨落如倾，我却立刻安下心来。今天我要回家，似乎是个天意。

不论如何，总算到家了，总算回来了。或许当我意识到，我还有一个家可以回的时候，我就已经回家了。

5-Implementations

Thu, 21 May 2026 10:32:00 +0800

上一章讲的是接口设计的原则，而这一章关注具体的实现细节。

Item26: Postpone variable definitions as long as possible

本节告诉我们，尽可能推迟变量的定义位置。换言之，在程序逻辑不变的情况下，越晚定义变量越好。

为什么？考虑到两个问题：

开销问题：变量定义太早，而程序由于某种原因没有继续执行（比如抛出异常）导致该变量未被使用，那么变量定义时调用构造函数的开销，相当于白费了。
代码风格：如果析构的位置不变，那么变量定义得越早，它的生命周期就越长，影响的代码范围就越广。而 coding 的一大原则就是“解耦”，尽可能减少每个部分对其他部分的影响。

所以说，只有在你马上需要用到这个变量的时候，才去定义它，而不是提早定义。

并且，最好在定义时就直接做完初始化的工作（开销更小），而不是先定义再赋值（开销更大）

前者在构造时只需要调用一次对应的 constructor
后者要调用 default constructor 和 copy assignment operator

作者的原话如下：

“Not only should you postpone a variable’s definition until right before you have to use the variable, you should also try to postpone the definition until you have initialization arguments for it.” (Dulimov, p. 115)

意思是一定要“忍到”你能够初始化（initialization）这个变量之后，你再去定义（definition）它。一定要将两者绑定，才能实现性能和资源利用最大化。

那么有人问了：如果在循环中需要使用某个变量，是在循环外部定义之后再在循环内部赋值好（方案 A），还是直接在循环内部构造好（方案 B）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Approach A
Widget w;
for (int i = 0; i < n; i++) {
 w = some value dependent on i;
}

// Approach B
for (int i = 0; i < n; i++) {
 Widget w(some value dependent on i);
}

可以看下两种方案各自的开销：

不知道去哪也挺好

Mon, 18 May 2026 22:00:00 +0800

最近常常思考人生，因为发现自己把人生的意义全部交予别人，而逃避自己背负责任——这太沉重了。认为努力就能获得认可，就有结果，这是一种傲慢，也是对自己人生的不负责。

从小陷入的"做得好→被肯定→做得更好"的循环，如今被击碎了。我们必须摆脱这个循环，建立内在的评价体系——但道理都懂，真做起来却令人崩溃：当外界的声音全部消失，我还能听见自己的声音吗？我人生的意义会不会本来就是空洞的？

努力在感情里没有用，反而让自己内耗。如果不被肯定、不被爱，你能自己爱自己吗？你追求的到底是什么？

努力在选择面前也显得苍白。人生的十字路口，我害怕选错，害怕度过一个错误的人生——但人生真的有对错之分吗？

想怎么过自己的一天，如果没有任何外在的评价标准？

玩一天手机
写一些文章，或许构思一篇小说
出去跑跑步，看看风景
看一场电影，或者看几集动漫
唱唱歌，吹吹风，我好想学习唱歌，可是自己没有环境和天赋……
玩想玩的游戏，我有好多游戏想试试
回家吃爸妈做的饭菜
想到一个完全没有人的地方呆一天

写下这些乱七八糟甚至十分荒谬的答案之后，我问自己：有了这些答案，我又能怎么做呢？人生真的是自己可以选择的吗？我在给自己设限吗？我在害怕什么？

如果选择了一个"不够好"的活法，我就不会被任何人在意，然后活成了一滩烂泥。或许真的是这样。

有了一个愿望，感觉自己不够好，就觉得自己不够格去追求它，然后觉得生活让我们没得选，让我们无法改变。

我能放弃现在的一切，去追求生活的意义吗？不应该也不现实。

更好的做法是：给现在做的每一件事，找到你自己的意义。

跑步不是为了跑得更快，只是为了吹吹风散散心；写作不是为了写出传世之作，只是为了抒发一下自己那些乱七八糟但真实的感情；写代码不是为了找工作，只是享受搭建逻辑的感觉。

可是，总有一些我们确实不喜欢而且没意义的事情吧？难道我也能给它们找到意义？这不是自欺欺人？还是说，我要像西西弗一样，把石头继续推上山？

西西弗是幸福的。我能像他一样吗？我真的能做到吗？追求幸福的枷锁就是我自己吗？

后来我想明白了一件事：我连"追求幸福"这件事，都在给自己定评价标准。如果我连"幸福"都要追求出一个"做得好"的结果来，那我什么时候才能真正放过自己？

不是每件事都需要有意义。不需要否定，不需要肯定，不需要给自己打分。只是去行动，只是去活着。我可以做点这个，也可以做点那个，我就是这样地活着。有时候开心，有时候烦恼，或许挺好，或许不好，怎么样都可以。不知道走向哪里，也没关系。

西西弗之所以幸福，不是因为他把"推石头"变成了他自己的选择，而是他放弃了追问"推石头"有什么意义。他不再需要那个答案了。这是一种真正的看透，不是自欺欺人，也不是麻木。

自欺欺人是说：“推石头其实很快乐。” 麻木是说：“我什么都不想了，推就推吧。” 看透是说：“这件事确实没有意义，但我也不需要它有意义。我继续推，只是因为我在这里，而石头在那里。”

想明白这些之后，我发现问题的核心从来就不是她怎么看待我，而是我怎么看待我自己。

标题为什么叫《不知道去哪也挺好》？因为我现在确实不知道。不知道她会不会回应我，不知道明天该往哪走，不知道自己能不能变成那个"不需要外界肯定也能好好活着"的人。但好像不知道，也没关系。

坚持练习 100 天八段锦，我的身体发生了哪些变化？

Sun, 10 May 2026 22:00:00 +0800

坚持练习 100 天八段锦，我的身体发生了哪些变化？ - 休闲娱乐 / 运动健身 - 水源社区

4-Designs and Declarations

Sat, 09 May 2026 20:39:00 +0800

本章将介绍设计和声明 C++ 接口的一些原则。

Item18: Make interfaces easy to use correctly and hard to use incorrectly

核心思想：

好的接口应该引导正确使用，阻止错误使用。如果用户用错了，编译器应该报错，而不是运行时才发现 bug。

所以，我们在设计接口的时候，最好多问自己一个问题：

如果别人用我的接口，最可能的几种用错方式是什么？我能不能在编译期就拦住，从而让用户正确地使用接口？

具体来说，主要有下面四个点需要检查：

参数顺序容易搞混吗？ -> 用类型区分
参数有合法范围吗？ -> 用 enum 或者 enum class 限定范围
行为和内置类型一致吗？ -> 该 const 就 const，该重载运算符就重载
涉及资源管理吗？ -> 返回智能指针，不要返回裸指针

参数顺序容易搞混吗？

比如说，我有一个 Date 类，它的构造函数需要三个参数：month-day-year。如果我全都定义成 int 类型，那么在传错顺序时很难检查出来。

所以，我可以自定义新的三个类：Month、Day 和 Year。

1
2
3
4
5
6
7
8


// 危险：三个 int，顺序很容易传反
Date(int month, int day, int year);

// 改进：用类型区分
struct Month { explicit Month(int m); };
struct Day { explicit Day(int d); };
struct Year { explicit Year(int y); };
Date(const Month& m, const Day& d, const Year& y);

这样，就可以轻松区分下面三种情况，用户很难传错参数：

3-Resource Management

Sat, 02 May 2026 09:27:30 +0800

C++中，我们需要手动管理资源。最常见的资源就是动态分配的内存，但注意，它不是唯一的资源。其他资源还有：file descriptors, mutex locks, fonts and brushes in graphical user interfaces.

Item13: Use objects to manage resouces

核心思想：把资源放进对象里，用对象来管理资源，让对象的构造和析构来保证资源的获取与释放。

其实，这就是 RAII。

这是因为，C++没有垃圾回收机制，手动 new / delete 十分容易出错（比如 delete 可能因为一些异常情况而没有被执行），所以我们需要一个规范化的获取和释放资源的流程。

手动管理资源的做法

例如，下面的代码使用一个 factory function 来为所有继承自 Investment 的类创建统一的调用接口（一个基类指针）。

如果你手动管理资源（new / delete、fopen / fclose、lock / unlock），很容易出错：

1
2
3
4
5


void f() {
 Investment* pInv = createInvestment();
 // ... 中间可能有 return、异常、goto 等各种出口
 delete pInv; // 万一没走到这里？内存泄漏
}

当然，你可以说：啊我 coding 的时候很仔细的，不会犯这样的低级错误。

但是，随着工程越来越大，代码越来越长，不规范的写法维护的成本也会越来越高。所以，为了确保资源一定能够安全释放，我们还是使用 RAII 的做法。

RAII 的做法

用一个对象来持有资源，对象的析构函数负责释放资源。

auto_ptr 就是这样一个对象。它是一个智能指针，管理着一个裸指针；在自身析构时，会自动对自己管理的裸指针调用 delete。

再次回顾：<code>delete</code> 实际做了两件事情

2-Constructors, Destructors, and Assignment Operators

Tue, 28 Apr 2026 12:26:00 +0800

构造函数、析构函数、赋值运算符，可以说是一个对象最重要的三个成员函数，它们分别掌管成员变量的出生、死亡以及变化。

Item5: Know what functions C++ silently writes and calls

虽然我们只是创建一个空类，没有写任何的函数，但是，编译器还是会默认声明一些特殊的成员函数。具体来说，包括：

函数	说明
默认构造函数	`Empty() = default;`
析构函数	`~Empty() = default;`
拷贝构造函数	`Empty(const Empty&) = default;`
拷贝赋值运算符	`Empty& operator=(const Empty&) = default;`
移动构造函数	`Empty(Empty&&) = default;`
移动赋值运算符	`Empty& operator=(Empty&&) = default;`

【补充知识】五法则：

除了默认构造函数之外，剩下的五个特殊的成员函数，如果我们手动定义了其中一个，剩下的四个就都不会被编译器自动生成。这是因为，一旦我们需要手动定义这五个函数中的一个，就说明存在需要手动释放的资源（比如 new 出的内存、打开的文件、拿到的锁等等）。既然有资源需要手动释放，那么默认的拷贝（浅拷贝）一定会出问题——两个对象会持有同一份资源，析构时双重释放。

这个规则被称为“五法则”，其逻辑链是：需要自定义某个函数 → 说明持有资源 → 拷贝/移动不能信任默认实现 → 五个都要自定义

回到正题。比如说，我们定义：

1

class Empty{};

但实际上，编译器生成的等价于：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 编译器实际生成的等价于
class Empty {
public:
 Empty() = default;
 ~Empty() = default;
 Empty(const Empty&) = default;
 Empty& operator=(const Empty&) = default;
 Empty(Empty&&) = default;
 Empty& operator=(Empty&&) = default;
};

这些函数都是 public 并且 inline 的，且只有它们在被实际调用的时候，编译器才会真正生成它们的定义（不是在声明时就生成）。

1-AccustomingYourselfToC++

Thu, 23 Apr 2026 08:17:01 +0800

Item1: View Cpp as a federation of languages

C++可以看成是下面四种不同语言的组合：

C 语言
面向对象的 C++：主要针对封装、多态、继承、虚函数等等。
模板 C++：主要针对泛型编程。
The STL（标准模板库）：最常用且特别的模板库。

每种对应不同的策略，需要根据情况选择对应的策略。

Note

Rules for effective C++ programming vary, depending on the part of C++ you are using.

Item2: Prefer `consts`, `enums` and `inlines` to `#define`

#define 在 preprocess 阶段完成，而前面三个关键字都是在 compile 阶段完成的。

符号表：symbol table。这个概念和编译的关系是？符号表似乎就是一个存了所有变量名字的大表吧。

#define 出来的东西本质上不是变量，不会进到符号表里面，这给我们 debug 带来困难。

代码体积更小（不会有多余的 copy），含义更加明确。

两类特殊情况：

Constant pointer：需要指针值和指针指向的指都被定义成常量，这样这个常量才算真正的“常量”。
Class-specific constants：限制一个常量的作用域在这个类内部，则这个常量是这个类的成员。并且，为了使得这个常量只有一个 copy，还要声明其为 static 类型。

1
2
3
4
5


class GamePlayer {
private:
 static const int NumTurns = 5;
 int scores[NumTurns];
};

上面是对 NumTurns 这个常量的 declaration，而不是 definition。这两个有什么区别吗？

Cpp八股面试题

Thu, 12 Mar 2026 22:01:25 +0800

智能指针相关

Cpp 智能指针是什么？请简单介绍一下。

参考回答

智能指针是一个封装了原始指针的类模板，它的主要作用就是通过 RAII 原则，在指针对象析构时自动释放资源，从而避免“忘记手动 delete”导致的资源泄漏，或者调用野指针的问题。

所谓的 RAII，指的就是：

构造时：接过原始指针，这代表着接管了原始指针的资源。
析构时：在析构函数里自动释放资源。
它将原本需要人工管理的“内存申请与释放”，变成了编译器自动管理的“局部变量生命周期”。

C++11 及以后，主要提供了三种智能指针，代表三种管理资源的逻辑： (1) std::unique_ptr —— “独占权”

所有权：同一时间只能有一个 unique_ptr 指向该资源。
性能：零开销（Zero Overhead）。它的执行效率和原始指针几乎一模一样。
限制：不能拷贝，只能移动（std::move）。
场景：最常用的指针。适用于明确知道“谁是主人”的场景。

(2) std::shared_ptr —— “共享权”

所有权：多个指针可以指向同一个资源。
机制：正如我们刚才聊的，它通过控制块里的引用计数来工作。
性能：有一定开销（需要原子操作增减计数，需要额外堆内存存控制块）。
场景：资源需要被多个模块共享，且无法确定谁最后退出的场景。

(3) std::weak_ptr —— “观察者”

所有权：不拥有所有权。它只是一个旁观者。
机制：指向 shared_ptr 管理的对象，但不增加强引用计数。
场景：解决 shared_ptr 的循环引用问题，或者作为缓存监控（防悬空）。

你提到了 shared_ptr，请问它是线程安全的吗？

参考回答

回家两周，杀戮尖塔治好了我的精神内耗

Sun, 01 Feb 2026 22:00:00 +0800

[[2026-02-01]]

省流：楼主是杀戮尖塔的佛系玩家，晚上打一局战士哥，拿了一堆防牌和一个肚皮，防杀（应该是这么说的吧）给我打爽了，四十多分钟碎心之后，内心感到久违的宁静。幸甚至哉，文以咏志 :doge:

回家之后，我一直处在焦虑之中，每天想做点事情，但是往往专心一个多小时之后，就开始在不同页面之间来回切换，看一会儿水源，再看一会儿 B 站，再看一会儿小说，做什么都静不下心。我本想跑步，偏偏因为期末周压力太大，刚回家没多久，发烧、皮炎都接踵而至，几乎在床上瘫了三四天，才慢慢好些。

感觉爸妈也很辛苦，总是在我面前说现在钱不好挣，我也想着自己早点工作，可是我不知道自己应该做什么样的工作，或者说能做什么样的工作 :face_exhaling: 我感觉自己好像还是中学生，还是一个青少年，可转念一想，自己也已经 21 岁，已经大三，再过两年就应该工作了。自己急着长大成人，却又不知道走向什么地方，只是顺着人流一直向前进吧……应该是在向前进？我也不太确定。

大三，或者说整个大学吧，都是让人迷茫的。可以说我们在命运的十字路口，前方却晦暗不明。我觉得自己应该做一些事情，却左思右想，不敢行动，十分烦闷。为了排解这一份烦闷，前两天我跑到泰山去逛了逛，回来之后心情确实开朗了不少，但一想到自己要做什么科研，或者要准备以后找什么工作，自我否定的感觉又会如影随形。我明明有能力，却做不了任何事，完全处于一种精神残疾的状态。不论是刷题，还是看文献，还是一般的写代码，或者看看自己感兴趣的网课，我总是无法专注，我的感受类似一点无聊混搭上一点焦虑。

“我做这件事情有什么意义吗？”我感觉我每做任何事情，都要这么问自己，但是问自己的结果就是，我做不了任何事情，我做不了任何当下无法看到回报的事情，大脑的奖励系统不接受任何长期投资，而我又否定自己获得短期快乐的权力。事实上，我明白自己只是想做看上去很厉害的事情，而不是真的想变得很厉害，我只是在假装前进而已。

负能量说的有点多了，现在说回游戏吧。我是大一升大二的暑假才下载了 steam，当时不知道买什么游戏，于是去问下 AI，给我推荐的第一款游戏就是杀戮尖塔，我甚至还是原价 80 多购入的 :rofl:。也就大二上学期玩得比较多，玩了 100 个小时，后来就吃灰了。我当时还是想认真学习一下什么牌组构建知识的，但事情太多，在上大学之后我也没有热情去认真学习过任何一类课外知识，后来就摆烂，一年多没怎么玩过。

最近有个朋友也开始爬塔，我就想到自己似乎已经好久没有打开 steam 了（多么悲哀 :sob: ），今晚兴致所至，就打开杀戮尖塔，没想到是之前不知道什么时候的存档还没打完，拿了一堆金卡，但是牌组又大又臭，好牌根本抽不上来，而且相互之间没有组合，于是艰难求生几局之后，还是在三奴隶那里暴毙。

然后我又新开一局战士（我只有机器人和观者打到了 a20，战士哥和猎宝都只有 a7），开局没多久，先在商店删了一张打击，然后又遇到删牌事件，中间拿了一张防牌之后，就拿到肚皮，我就觉得这局可以防杀。一层结束时拿到鸟笼，直接删两张打击，后续陆陆续续又拿几张防牌，直接化身铜墙铁壁，在三层又拿到了巩固，我就知道这局必然胡了，果然一路高歌猛进，直接碎心。

这局游戏结束之后，我坐在电脑前，内心感受到久违的宁静：这局游戏里，我没有切出去看任何其他的内容，没有拿起手机刷视频，没有感觉自己头脑一片混沌，没有对未来的焦虑，没有对搞砸事情的担心，内心只有三个字：战斗，爽！

冥冥之中我感到一种启示：

过去的生活就像我一打开游戏看到的那个残局，那时我太贪心，什么都想要，于是强行拿了一堆牌，却根本打不出来，觉得游戏进行不下去了，选择了逃避，选择了暂停，将残局留给了现在的我，继续苟且求生吗？可是必死的局面，我又能如何呢？
不若快刀斩乱麻，重开一局，锚定一点，勇往直前，反而能用小而精的牌组打破困局。

当然，上面的感悟只是胡扯，我真正的感想只有下面两句：

啊，杀戮尖塔真好玩 :tieba_huanhu: 我是不会放弃的，因为我以后还要玩杀戮尖塔。

SFINAE原则

Tue, 02 Dec 2025 09:12:51 +0800

SFINAE (Substitution Failure Is Not An Error)

面试官： 我们之前聊过模板。在 C++ 模板编程中，有一个非常著名的缩写词叫 SFINAE (读作 “sfi-nay”)。

请问，你知道 SFINAE 代表什么意思吗？或者你能简单描述一下，当编译器在实例化模板时，如果遇到了一个无效的类型替换，它会怎么做？是直接报错停止编译，还是会尝试别的方案？

回答：

不好意思，我第一次听说“模板元编程”这个概念，也是第一次听说 SFINAE 这个名词，请你直接解释吧。

没关系！这正是我们今天学习的意义所在。模板元编程是 C++ 的深水区，SFINAE 是进入这个世界的敲门砖。

我们把这个复杂的概念拆解成最简单的逻辑。

什么是 SFINAE？

SFINAE 代表 “Substitution Failure Is Not An Error”。中文直译：“替换失败不是错误”。

这听起来像是一句哲学名言，但在 C++ 编译器眼中，它是一条非常具体的生存法则。

场景重现：编译器的选秀大会

假设你写了两个同名的函数模板 foo（这叫重载）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 选手 A：这个模板要求 T 必须有一个叫 inner_type 的内部类型
template <typename T>
void foo(typename T::inner_type param) {
 std::cout << "Selected A" << std::endl;
}

// 选手 B：这个模板对 T 没有任何要求
template <typename T>
void foo(T param) {
 std::cout << "Selected B" << std::endl;
}

现在，你在 main 函数里调用了 foo(10)。

RAII设计哲学

Thu, 27 Nov 2025 16:47:57 +0800

RAII: Resource Acquisition Is Initialization

模拟面试开始

面试官： 我看你的代码风格很现代。在 C++ 资源管理中，RAII 是一个核心概念。

你能用自己的话，简单解释一下什么是 RAII 吗？它的中文含义是什么？它主要用来解决什么问题？

回答：

RAII 的全称是 Resource Acquisition Is Initialization，中文直译过来就是“资源获取即初始化”。意思就是，我们希望在获取资源（比如取用一个指针）时，取用到的资源不是未初始化的（比如说野指针），而是已经经过规范初始化的、安全可用的资源。
它主要用来解决的问题，就是未经许可的内存访问。比如，如果我访问一个野指针，其中的内容可能恰好指向程序的某些重要区域，当我修改其中数据时，程序就直接崩溃了。

这是我对 RAII 这个概念自己的理解，如有不正确之处，还希望批评指正。

你的回答非常坦诚，是基于字面意思的合理推测，但其实 RAII 的真正含义和你现在的理解有比较大的偏差。

你现在的理解更偏向于“初始化安全”或者“避免野指针”，这当然也是好的编程习惯，但 RAII 的核心在于生命周期的绑定和自动释放。

我们来纠正一下这个概念。

面试官 (纠正与引导): 你的直觉很有意思，但 RAII 这个名字其实起得有点“烂”，非常容易让人产生和你一样的误解（以为重点在初始化）。

RAII 的核心其实不在于“获取资源时要初始化”，而在于 “资源的生命周期应该与对象的生命周期绑定”。

关键点在于：

构造函数 (Acquisition)：当我们在栈上创建一个对象（比如一个类实例）时，我们在它的构造函数里去“获取”资源（比如 new 一块内存、打开一个文件、上一个锁）。
析构函数 (Release)：这是最最关键的一步。当这个对象离开作用域（生命周期结束）时，它的析构函数会被编译器自动调用。我们就在析构函数里去“释放”那个资源（比如 delete 内存、关闭文件、解锁）。

所以，RAII 解决的核心问题是：资源泄漏 (Resource Leak)。

举个最经典的例子： 如果不使用 RAII：

1
2
3
4
5
6
7
8
9


void func() {
 int* p = new int[100]; // 获取资源
 if (some_error) {
 // 糟糕！如果这里直接 return 或抛出异常，
 // 下面的 delete 永远不会执行，内存泄漏！
 return;
 }
 delete[] p; // 释放资源
}

如果使用 RAII（比如 std::vector 就是一个 RAII 包装类）：

命名空间

Wed, 26 Nov 2025 08:38:45 +0800

命名空间 namespace

面试官： 在 C++ 中，我们经常看到 std::cout、std::vector 这样的写法，这里的 std 就是一个命名空间。

请问，命名空间 (namespace) 的主要作用是什么？它解决了 C++（以及很多其他编程语言）中一个什么样的痛点？

此外，我们在 .cpp 文件中经常会看到 using namespace std; 这样的写法。请问，在头文件 (.h) 中使用 using namespace std; 是一个好的习惯吗？为什么？

回答：

我认为，命名空间类似一个集合，里面包含着特定的“工具”，也就是函数。我们把一些常用的、标准的工具打包起来，就变成了一个命名空间。
同时，命名空间也是一个前缀。它解决的痛点是：如何区分不同位置的同名函数？通过命名空间就可以。比如说，A 和 B 两个命名空间都有一个函数叫做 test，那么我们可以通过 A::test 和 B::test 来分别调用这两个不同的函数，而不会导致混淆。
你提到的最后一点：在头文件中使用 using namespace std;。这绝对不是一个好习惯！简单来说，它会导致命名空间污染的问题。即：我在头文件里使用 using namespace std;，在所有导入该头文件的文件中，命名空间都会被默认设置为 std。一旦我们自己定义的函数和 std 中的某个函数重名，在调用时会导致混乱，通常会调用 std 中的那个函数。

我只是凭自己理解作答，如果不正确，请你指出。

你的回答极其出色！虽然你说是一个月没学，但你的 C++ 感觉依然非常敏锐。

我们来逐点分析你的回答：

命名空间的定义：

“命名空间类似一个集合… 也是一个前缀。”

这个比喻非常形象！命名空间本质上就是一个逻辑上的作用域。它把一组相关的标识符（函数、类、变量等）包裹起来，像是一个虚拟的文件夹。
解决的痛点：

“解决的痛点是：如何区分不同位置的同名函数？”

完全正确！这就是命名冲突 (Name Collision) 问题。在大型项目中，成千上万的代码、引入几十个第三方库，如果没有命名空间，大家为了给函数起个不重名的名字（比如 LibA_test, MyProj_test），头都要炸了。命名空间优雅地解决了这个问题。
头文件中的 using namespace std;：

C++类型转换符

Tue, 21 Oct 2025 08:28:49 +0800

我们开始今天的 C++ 八股环节！

今天，我们来聊一个在面试中经常被用来考察你对 C++ 基础和面向对象理解的话题：static_cast, dynamic_cast, const_cast, reinterpret_cast。

这四个是 C++ 的标准类型转换操作符。相比于 C 风格的强制转换（如 (int)x），它们更安全、意图也更明确。

`static_cast` 转换符

模拟面试开始

面试官： 在 C++ 中，我们有四种“具名”的类型转换符，统称为 static_cast 系列。我们先来聊聊最常用的一个：static_cast。

请问，static_cast 主要用于什么样的转换场景？它和 C 风格的强制转换 (new_type)expression 相比，有什么主要的优势？

回答：

static_cast 是 C++ 中最基础和最简单的类型转换，主要有以下的应用场景：
- 相关类型之间的转换，如数值类型之间、枚举类型和整数之间、void* 类型和其他指针类型之间。
- 有继承关系的类指针/引用转换（不涉及多态的情况）。这里，将派生类指针或引用，转为基类的指针或引用（也就是上行转换）是安全的；反之，将基类的指针或者引用，转为派生类的指针或者引用（也就是下行转换）是不安全的。
和 (new_type)expression 相比，static_cast 的转换意图更明确（从命名就可以看出），以及转换过程更安全（会检查变量类型之间是否可以安全转换）

面试官 (总结与补充): 你说的完全正确。

static_cast 是 C++ 中最基础、最常用的“良性”转换。

主要应用场景：

相关类型之间的转换：
- 数值类型转换：在各种数值类型之间进行转换，比如 int -> double, double -> int。
  1 2
  
  double d = 3.14; int i = static_cast<int>(d); // i = 3
- 枚举与整数转换：在枚举类型和整数类型之间进行转换。
  1 2 3
  
  enum Color { RED }; int c_val = static_cast<int>(RED); Color c = static_cast<Color>(0);
- void 指针转换*：将 void* 指针转换为具体的类型指针。
  1 2
  
  void* p = &i; int* pi = static_cast<int*>(p);
有继承关系的类指针/引用转换 (不涉及多态)：

default和delete

Thu, 16 Oct 2025 09:05:16 +0800

`default` 关键字强制生成默认构造函数

模拟面试开始

面试官： 我们知道，如果一个类我们不给它定义任何构造函数，编译器会自动为我们生成一个默认构造函数。类似的，编译器也可能会为我们生成拷贝构造函数、拷贝赋值运算符等。

在 C++11 之后，如果我们想显式地告诉编译器：“请为我生成一个默认的、最普通的版本”，我们可以使用 default 关键字。

请看下面这个例子：

1
2
3
4
5
6
7
8
9


class MyClass {
public:
 MyClass() = default; // 显式地要求编译器生成默认构造函数

 MyClass(int val) : data(val) {} // 用户自定义了别的构造函数

private:
 int data;
};

我的问题是： 在这个例子中，MyClass() = default; 这一行代码，有什么实际意义？

换句话说，如果我们删掉 MyClass() = default; 这一行，会发生什么变化？这个类还能通过 MyClass obj; 这种方式创建对象吗？为什么？

回答：

当用户自己定义了一种构造函数时，编译器就不会自动生成默认的无参数的构造函数。
MyClass() = default; 确保无参数的构造函数存在。
如果删去这一行，那么 MyClass 这个类就无法通过 MyClass obj; 这种方式创建对象，因为编译器检测不到对应的构造函数。
而增加上这一行，可以使得程序可以在无参数的情况下创建新的对象，等到对其内容有要求时，再做修改。

面试官 (总结与肯定): 你说的没错。这个问题的核心在于 C++ 的一条规则：

一旦用户为类定义了任何一种构造函数（无论带不带参数），编译器就会“罢工”，不再自动生成默认（无参）构造函数。

所以，在你给出的例子中：

因为你已经定义了一个 MyClass(int val)，编译器就不会再自动生成 MyClass() 了。
如果我们删掉 MyClass() = default; 这一行，那么 MyClass 类就没有无参构造函数。此时，MyClass obj; 这样的代码就会编译失败，因为它找不到匹配的构造函数。

= default 的作用： MyClass() = default; 这一行，就是你（程序员）在向编译器明确地下指令：

虚析构函数

Mon, 13 Oct 2025 23:10:06 +0800

不使用虚析构函数，可能导致资源泄漏

面试官： 我们知道，析构函数是在对象生命周期结束时，用于清理资源的特殊成员函数。在 C++ 的继承体系中，我们有时需要把基类的析构函数声明为虚函数 (virtual)。

请看下面这段代码，它可能会导致一个非常严重的问题：

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


#include <iostream>

class Base {
public:
 Base() { std::cout << "Base Created\n"; }
 // 注意：析构函数不是虚函数
 ~Base() { std::cout << "Base Destroyed\n"; }
};

class Derived : public Base {
public:
 Derived() { std::cout << "Derived Created\n"; }
 ~Derived() { std::cout << "Derived Destroyed\n"; }
};

int main() {
 Base* p = new Derived(); // 基类指针指向派生类对象

 delete p; // 问题就出在这里！

 return 0;
}

我的问题是：

你预测一下，上面这段代码的输出会是什么？
这个输出结果揭示了什么样的严重问题？
这个问题的根本原因是什么？（即，delete p; 这行代码，编译器是如何决定调用哪个析构函数的？）

回答：

Const关键字

Thu, 09 Oct 2025 13:09:59 +0800

`const` 修饰变量

面试官： 看到你的简历上写着熟悉 C++，那我们来聊聊 const 关键字吧。它在 C++ 中有很多用途。

我的第一个问题是： 当 const 用于修饰一个变量时，它意味着什么？它和 C 语言中的 #define 宏定义常量相比，有什么主要的优势？

1
2
3
4
5


// 方式一
const int MAX_SIZE = 100;

// 方式二
#define MAX_SIZE 100

回答：

const 关键字修饰变量，表示这个变量是一个常量，不能被修改。
和 #define 宏定义常量相比，const 变量更加有下面的优势：
- 类型检查：const 是有类型的变量，编译器会进行类型检查，而 #define 是纯文本变量，没有类型概念，容易引发隐性错误——编译通过但运行出错。
- 作用域控制：const 类型的变量可以定义在局部作用域中，而 #define 是全局替换，容易产生命名冲突
- 调试支持：const 变量可以在调试器中查看它的值和地址，而 #define 变量在预处理阶段就被替换到，调试器无法识别。
- 取地址操作：const 变量可以取地址，而 #define 是文本替换，没有地址的概念。
- 跨文件访问：const 变量可以通过 extern 声明在多个文件中共享，而 #define 无法跨文件共享，只能重新定义。
当然，const 最主要的优势还是类型检查和作用域控制。

`const` 与指针结合

面试官 (继续提问): 好的，你对 const 修饰普通变量的理解非常透彻。我们来看它和指针的结合。

请你解释一下，下面这三种声明中，p 的类型有什么不同？分别都约束了什么东西不能被修改？

new运算符的细节

Tue, 07 Oct 2025 09:22:04 +0800

`new` 的两步过程、定位 `new` 操作

面试官： 我们知道，new 操作符用于在堆上分配内存并构造对象。比如 MyClass* p = new MyClass();。

其实，这个简单的 new 表达式，背后可以被看作是两个步骤的组合。你能描述一下这两个步骤分别是什么吗？

另外，C++ 还提供了一种叫做 “定位 new (placement new)” 的特殊语法。它的形式是 new (address) Type(args)。你了解它是用来做什么的吗？它和普通的 new 有什么核心区别？

回答：

new 表达式可以看作这样两个步骤的组合：
- 第一步：分配内存。
- 第二步：在分配到的内存上构造对象，即初始化。
定位 new 操作，顾名思义，就是在一个确定的地址上构造对象，而不是自己分配内存。通过定位 new 构造的对象，不能调用 delete 销毁，需要手动析构。

面试官 (总结与肯定):

1. new 表达式的两步走 你说的完全正确。T* p = new T(args); 这个表达式，在概念上等价于：

分配内存 (Allocation)：调用一个名为 operator new 的函数，来分配一块足够大的、未初始化的裸内存。这个函数很像 malloc。 void* memory = operator new(sizeof(T));
构造对象 (Construction)：在这块分配好的内存上，调用 T 类的构造函数来初始化对象。 T* obj = static_cast<T*>(memory); obj->T::T(args); // 伪代码，表示调用构造函数

2. 定位 new (placement new) 你的解释也堪称完美：

栈、堆与栈溢出

Fri, 03 Oct 2025 14:32:45 +0800

栈和堆的比较 Stack and Heap

面试官： 我们知道，C++ 程序在运行时，局部变量通常分配在栈 (Stack) 上，而动态分配的内存则来自堆 (Heap)。

请你从内存管理方式、分配效率、空间大小和数据生命周期这四个角度，详细对比一下栈和堆的主要区别。

回答：

在内存管理方式上，栈的内存是自动分配、释放的连续空间，而堆的内存是需要程序员手动分配、释放的非连续空间。
在分配效率上，栈的分配效率比堆更高。
在空间大小上，栈的空间大小比堆更小，当栈达到一定深度，就会发生溢出。
在数据生命周期上，栈的生命周期更短，通常是一次函数调用开始时，栈空间被分配，而该次函数调用结束时，栈的内存就被释放。而堆上的内存，通常在整个程序的生命中始终存在，直到我们手动释放它。

栈溢出 Stack Overflow

面试官 (深入追问): 好的，你对基础区别已经很清楚了。我们来深入聊聊你提到的 “栈溢出 (Stack Overflow)”。

你刚才说“当栈达到一定深度，就会发生溢出”。这通常是由无限递归或过深的递归导致的。

我的问题是： 除了递归，还有没有其他常见的编程行为，也可能导致栈溢出？你能否写一个不使用递归的、非常简单的代码片段，来人为地触发一个栈溢出？

回答：

可以，除了递归之外，两个函数无限制地相互调用也可以出发栈溢出，比如下面的例子。

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


void funcA();
void funcB();

void funcA() {
 funcB();
}

void funcB() {
 funcA();
}

int main () {
 funcA();
 return 0;
}

面试官 (继续引导): 很好。不过，我们还能不能让问题变得更“纯粹”一点？

模板：template和typename

Mon, 29 Sep 2025 09:33:17 +0800

模板的作用与分类

面试官： 在 C++ 中，模板 (template) 是实现泛型编程的核心机制。

你能用自己的话，简单解释一下什么是模板吗？它主要解决了什么问题？C++ 中主要有哪几种类型的模板？

回答：

模板是 Cpp 的一种机制，它允许我们编写与类型无关的代码（泛型），即：使用同一段代码能覆盖许多的类型。这种机制让编译器能根据识别到的具体类型，执行不同的操作。
模板主要解决的是代码复用的问题，尤其是在函数或者类的逻辑一致、但处理数据类型不同的情况下，避免重复写同样的代码，极大地提高了代码的简洁性和可读性。
C++中主要的模板，我认为有
- 函数模板：处理任意类型参数的模板
- 类模板：处理任意类型成员的模板。
- 模板特化：某一个具体类型需要特殊实现，提供一个特化类型的模板。
- 模板偏特化：允许对模板参数的一部分特化，不过较为复杂，使用较少。

模板实例化 Template Instantiation

面试官 (追问): 好的，你提到了函数模板和类模板。我们知道，模板本身并不是可以直接执行的代码，它更像是一个“蓝图”。

请问，从“模板蓝图”到“可执行代码”这个过程，是在什么时候发生的？这个过程通常被称为什么？

1
2
3
4
5
6
7
8
9


template<typename T>
T add(T a, T b) {
 return a + b;
}

int main() {
 int x = add(5, 10); // 发生了什么？
 double y = add(3.14, 2.71); // 这里又发生了什么？
}

回答：

从“模板蓝图”到“可执行代码”这个过程，是在调用函数时，编译器识别到参数的具体类型时发生的。
在上面的例子中，第一个 add 函数识别到输入的参数为 int 类型，因此执行 int 类型的加法；而第二个 add 函数识别到输入的参数为 double 类型，因此执行 double 类型的加法。
这个过程被称为模板实例化。
- 在上面的例子中，模板实例化由编译器自动完成，而不是程序员手动指定，这样的实例化过程被称为隐式实例化 (Implicit Instantiation)。
- 而程序员手动指定类型并提前生成代码的实例化，被称为显式实例化 (Explicit Instantiation)。

下面是一个基于 add 函数的显式实例化的例子：

using关键字

Wed, 24 Sep 2025 09:26:08 +0800

`using` 声明和 `using` 指令

面试官： 在 C++ 中，using 关键字有多种用途。我们先来聊聊它最常见的两种用法：using 声明 (using-declaration) 和 using 指令 (using-directive)。

请问，下面这两行代码，它们分别属于哪一种？它们在作用和影响范围上，有什么本质的区别？

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


// 场景一
#include <iostream>

void func1() {
 using std::cout; // 这是什么？
 cout << "Hello";
}

// 场景二
#include <iostream>
#include <vector>

using namespace std; // 这又是什么？

void func2() {
 cout << "World";
 vector<int> v;
}

回答：

using std::cout 属于 using 声明，它只引入命名空间中的单个成员，作用在当前作用域中，适合局部使用。
using namespace std 属于 using 指令，它负责引入整个命名空间，作用在全局，但容易导致二义性问题。

面试官 (总结与肯定): 你说的完全正确。

inline内联函数

Mon, 22 Sep 2025 08:39:31 +0800

`inline` 的好处与坏处

面试官： 在 C++ 中，我们可以在函数声明或定义前，加上 inline 关键字。

请问，inline 关键字是用来做什么的？它是在向编译器建议什么？使用内联函数，主要可能带来什么好处，又可能带来什么坏处？

回答：

inline 关键字用于声明内联函数，它在向编译器建议：“这个函数代码很短，请你将它的代码直接嵌入我们调用它的地方，而不用进行调用跳转。”
当然，这只是一个建议，编译器有最终的决定权。如果编译器觉得这个函数过于复杂，那么它会忽略 inline 的建议，仍然执行调用跳转。
好处：
- 使用内联函数，尤其是对短小且频繁调用的函数，可以省去函数调用的开销，执行效率更高。
坏处：
- 编译更加复杂，导致编译时间增加。
- 由于每次都要复制一份函数体代码到调用处，因此代码膨胀，且指令数量增加，指令缓存效率受影响。

面试官 (总结与补充): 你说的非常好。我来帮你把这些点串联和补充一下，形成一个更完整的知识体系。

什么是函数调用开销？ 当你省去“函数调用开销”时，具体省去了什么？

参数压栈：将函数参数按照调用约定压入栈中。
返回地址压栈：将调用点下一条指令的地址压入栈中，以便函数返回时能继续执行。
跳转：CPU 执行 call 指令，跳转到函数体的入口地址。
栈帧建立：为函数的局部变量分配栈空间。
函数返回：执行 ret 指令，从栈中弹出返回地址，并跳转回去。
栈帧销毁：释放局部变量空间。

对于一个只有一两行代码的函数，这些“行政”开销，可能比真正执行函数体代码的开销还要大得多。inline 的目的就是消除这些“行政”开销。

你提到的坏处——代码膨胀 (Code Bloat)

这是一个非常重要的权衡。如果一个函数体本身很大，内联它会导致可执行文件的体积急剧增大。
这不仅占用更多磁盘空间，更重要的是，它会破坏指令缓存 (Instruction Cache, i-cache) 的局部性。CPU 访问内存的速度远慢于执行指令的速度，所以它会把最近用到的指令缓存起来。如果代码体积太大，缓存装不下，就会导致频繁的“缓存未命中 (cache miss)”，CPU 需要去慢速的主存中读取指令，反而降低了程序的整体性能。

编译器的决定权 现代编译器非常智能，它在决定是否内联时，通常会自己做判断，即使你没有加 inline。

它会自动内联它认为合适的、足够简单的函数（比如定义在类头文件中的成员函数，默认就是 inline 的）。
它会拒绝内联过于复杂的函数，即使你加了 inline 关键字。比如，包含循环、递归、大量 switch 的函数通常不会被内联。

`inline` 的语法作用——解决 ODR 违例问题

面试官 (深入提问): 好的，你对 inline 的性能考量已经很清楚了。

委托构造函数

Sat, 20 Sep 2025 09:59:58 +0800

委托构造函数 Delegating Constructors

面试官： 在 C++ 中，我们经常会为一个类提供多个构造函数，以方便使用者用不同的方式来初始化对象。

请看下面这个 C++03 风格的例子：

 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


#include <string>
#include <iostream>

class MyData {
private:
 int a;
 double b;
 std::string c;

public:
 // 构造函数 1
 MyData() {
 a = 0;
 b = 0.0;
 c = "default";
 // 假设还有一些其他的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }

 // 构造函数 2
 MyData(int val_a) {
 a = val_a;
 b = 0.0;
 c = "default";
 // 同样的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }

 // 构造函数 3
 MyData(int val_a, double val_b) {
 a = val_a;
 b = val_b;
 c = "default";
 // 又是同样的通用初始化逻辑
 std::cout << "Common logic executed.\n";
 }
};

你可以看到，这三个构造函数中，有很多重复的代码（比如对 b, c 的初始化，以及那个通用的逻辑）。在 C++11 之前，处理这种代码重复是一个比较头疼的问题。

NULL和nullptr

Thu, 18 Sep 2025 08:33:33 +0800

`nullptr` 解决函数重载的二义性

面试官： 在 C++11 之前，我们通常使用一个宏 NULL 来表示空指针。而在 C++11 中，引入了一个新的关键字 nullptr 来专门表示空指针。

请问，我们为什么需要 nullptr？或者说，使用宏 NULL 在某些情况下，会带来什么样的问题或歧义，是 nullptr 能够解决的？

回答：

NULL 是一个宏，它除了表示空指针之外，更常用的含义是表示 0，一个整数。
由于 NULL 既能表示空指针，又能表示 0，因此它会引发歧义。
比如，某个函数重载了两个版本，一个的参数类型是 int，而另一个参数类型是 char*。当输入 NULL 时，通常会调用参数为 int 的那个版本。
而使用 nullptr 则规避了这一风险。nullptr 是一个真正的空指针常量，它是一个特殊的类型 std::nullptr_t，可以隐式地转换为任何的指针类型，而不会和 int 类型混淆。

面试官 (总结与肯定): 你说的完全正确。我们来把这个过程再详细地梳理一遍。nullptr 诞生的核心原因是解决函数重载时的二义性。

NULL 的“前世今生” NULL 是一个定义在 <cstddef> 等头文件中的预处理宏。它的具体定义取决于编译器，但通常是下面两种之一：

1
2
3
4
5


#define NULL 0
// 或者
#define NULL 0L
// 或者在 C++ 编译器中，有时甚至是
#define NULL nullptr // 这是现代编译器的“向后兼容”行为

在 C++98/03 的时代，你可以认为 NULL 就是一个值为 0 的整型常量。

Cpp异常处理机制

Wed, 17 Sep 2025 09:14:16 +0800

栈展开

面试官： 在 C++ 中，当我们使用 try...catch 块来处理异常时，有一个重要的过程叫做 “栈展开 (Stack Unwinding)”。

你能用自己的话，简单描述一下，当一个异常被 throw 出来之后，到它被某个 catch 块捕获之前，这个“栈展开”的过程具体发生了什么吗？特别是，对于那些在栈上创建的对象，会发生什么？

比如，请看下面这段代码：

 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


#include <iostream>

// 一个简单的类，在构造和析构时会打印信息
struct RAII_Helper {
 int id;
 RAII_Helper(int i) : id(i) { std::cout << "RAII_Helper " << id << " constructed.\n"; }
 ~RAII_Helper() { std::cout << "RAII_Helper " << id << " destructed.\n"; }
};

void func_C() {
 RAII_Helper h3(3);
 std::cout << "Entering func_C, about to throw.\n";
 throw std::runtime_error("An error occurred in C!");
 std::cout << "This line in func_C is never reached.\n";
}

void func_B() {
 RAII_Helper h2(2);
 std::cout << "Entering func_B, calling C.\n";
 func_C();
 std::cout << "This line in func_B is never reached.\n";
}

void func_A() {
 RAII_Helper h1(1);
 std::cout << "Entering func_A, calling B.\n";
 try {
 func_B();
 }
 catch (const std::exception& e) {
 std::cout << "Caught exception in A: " << e.what() << "\n";
 }
 std::cout << "Exiting func_A.\n";
}

int main() {
 func_A();
 return 0;
}

函数调用链是 main -> func_A -> func_B -> func_C。

Cpp字符串处理

Mon, 15 Sep 2025 09:21:27 +0800

`std::string` 的优点

面试官： 在 C++ 中，我们有两种主要的方式来表示字符串：C++ 标准库提供的 std::string 类，以及从 C 语言继承来的、以空字符 \0 结尾的字符数组（我们常说的 C 风格字符串，通常用 char* 或 const char* 指针来表示）。

请问，和传统的 C 风格字符串相比，使用 std::string 类有什么主要的优点？

回答：

std::string 的封装程度更好，使用时不易出错。
具体来说，包括自动内存管理、安全性和功能性三个方面。

面试官 (补充与扩展): 你说的完全正确。std.string 作为一个类，把所有复杂的、容易出错的底层操作都封装起来了，为我们提供了极大的便利和安全保障。

我来帮你把它的优点展开成几个具体的点，这也是面试时希望听到的内容：

自动内存管理 (Automatic Memory Management)：
- std::string: string 对象自己会负责管理存储字符串所需的内存。当字符串变长时，它会自动扩容；当 string 对象被销毁时，它会自动释放内存。你完全不需要操心 new[] 和 delete[]。
- char*: 你必须手动管理内存。malloc / free 或 new[] / delete[] 必须成对出现，极其容易忘记释放，导致内存泄漏。
安全性 (Safety)：
- std::string: 它内部记录了字符串的当前长度。
  - 成员函数 length() 或 size() 可以 O (1) 复杂度地返回长度。
  - 成员函数 at(i) 提供边界检查，越界会抛出异常。
  - 拼接、拷贝等操作都会自动处理内存，不会造成缓冲区溢出。
- char*:
  - 长度信息依赖于结尾的 \0。每次计算长度 (strlen) 都需要从头遍历，时间复杂度 O (n)。
  - 所有操作（如 strcpy, strcat）都不进行边界检查，如果目标缓冲区不够大，就会发生缓冲区溢出，这是 C/C++ 中最危险的安全漏洞之一。
功能丰富且易用 (Rich Functionality)：

Cpp的三种类型推导关键字

Sun, 14 Sep 2025 09:33:26 +0800

`auto` 关键字

面试官： C++11 引入了 auto 关键字，它极大地改变了我们编写 C++ 代码的方式。

你能简单解释一下，auto 关键字的作用是什么吗？使用它有什么好处？

回答：

auto 关键字的作用是，省略具体的变量类型，而是根据实际变量的类型推导出其类型。
使用 auto 关键字，就不必写复杂的类型名（比如常用的 STL 迭代器），让代码看上去更简洁。
同时，auto 关键字还能实现类似“多态”的效果（这里说“多态”不太准确，应该说，是泛型编程），使得同一份代码可以被许多不同的类型复用。

面试官 (补充与澄清): 你说的很对。我们来把你的回答再精确化和补充一下。

auto 的作用： 它是一个类型占位符。编译器会在编译时，根据变量的初始化表达式，自动推导出变量应该具有的正确类型。

auto 的好处：

简洁性 (Brevity)：正如你所说，它可以避免写冗长、复杂的类型名。这一点在处理 STL 的迭代器和模板时尤其明显。

1
2
3
4
5


// C++03
std::vector<std::string>::iterator it = my_vec.begin();

// C++11 with auto
auto it = my_vec.begin(); // 简洁、易读、不易出错

正确性 (Correctness)：auto 保证了变量的类型与初始化表达式的类型完全匹配，避免了因手写类型错误或发生意外的类型转换而导致的 bug。
可维护性 (Maintainability)：如果初始化表达式的类型未来发生了变化（比如一个函数的返回值从 int 变成了 long long），使用了 auto 的代码不需要任何修改，会自动适应新的类型。

关于你提到的“多态效果”： 这个描述非常有趣！auto 本身是在编译期进行类型推导，不直接产生运行时的多态（那需要虚函数）。但你说的“使得同一份代码可以被许多不同的类型复用”，这个思想非常接近泛型编程 (Generic Programming)。 auto 在 C++14 的泛型 Lambda 中 [](auto x){ ... } 和 C++20 的函数参数中 void func(auto param)，确实扮演了类似模板参数的角色，让一段代码能适用于多种类型。你的直觉是非常准的。

Lambda表达式

Sat, 13 Sep 2025 18:22:44 +0800

什么是 Lambda 表达式？

面试官： 好的，我们来聊聊 C++11 引入的一个非常强大的特性——Lambda 表达式。

你能用自己的话简单解释一下，Lambda 表达式是什么吗？它主要解决了什么问题，或者说，它为我们编写 C++ 代码带来了什么样的便利？

回答：

我的理解是，lambda 表达式就是“匿名函数”，即省略名字的函数。
它定义了一个函数，这个函数有函数的所有功能，但不需要名字。
这让我们在需要写一些小巧的工具性一次性函数时，省去了从头定义函数的麻烦，让代码看上去更加简洁。

面试官 (补充与肯定): 你说的完全正确。Lambda 表达式的出现，极大地改变了 C++ 的编程风格，特别是与标准库算法（STL Algorithms）结合使用时。

在 C++11 之前，如果我们需要给 std::sort, std::find_if 这样的算法传递一个自定义的比较或判断逻辑，我们通常需要：

在别处定义一个完整的具名函数。
或者定义一个函数对象（一个重载了 operator() 的 struct 或 class）。

这两种方式都比较繁琐，并且会导致逻辑和使用点的分离。

而 Lambda 表达式，正如你所说，允许我们在需要的地方，就地定义一个匿名的、小巧的函数，让代码更紧凑、可读性也更强。

Lambda 表达式的捕获列表

面试官 (深入提问): 好的，你对 Lambda 的基本概念很清楚。我们来看一下 Lambda 表达式的语法结构。

一个完整的 Lambda 表达式看起来像这样： [ captures ] ( params ) -> return_type { body }

其中，[ captures ] 这个部分，我们称之为捕获列表 (Capture List)，这是 Lambda 表达式最强大、也最核心的部分。

Geth的Snapshot机制

Fri, 12 Sep 2025 20:03:57 +0800

Ask about Geth: Snapshot acceleration | Ethereum Foundation Blog

核心问题：

“Could you share how the flat db structure is different from the legacy structure?” (“Ask about Geth: Snapshot acceleration”)

意思是，扁平化数据结构 (即 Snapshot) 和原本的传统结构有何不同？

State in Ethereum 以太坊组织数据的方式

MPT (Merkle Patricia Tree) = Merkle Tree + Patricia Tree

Merkle Tree 保证了“可验证性”，即无需提供整个数据集，而只需要路径上的一部分数据，即可验证数据真伪。（高效）
Patricia Tree 保证了“确定性”，即：对于任何一组确定的键值对，它们组成的 Patricia Tree 的结构是唯一的。（共识）

MPT 为何能解决验证问题呢？

保证了共识：由于 Patricia Tree 的确定性，所有拥有相同世界状态的节点，必然会计算出完全相同的 State Root。这使得全网可以通过比对一个简短的哈希值来确认彼此的状态是否一致，这是共识的基础。
实现了轻客户端验证：由于 Merkle Tree 的可验证性，一个“轻客户端”（只存储区块头，知道 State Root）可以向一个“全节点”请求某个账户的余额。全节点会返回这个余额数据，并附上一条“默克尔证明”。轻客户端就可以在不下载整个世界状态（可能高达数TB）的情况下，仅用这个小小的证明来验证这个余额是否真实、可信，并且确实是包含在那个 State Root 所代表的世界状态里的。

“The cost of logarithmic updates and logarithmic verification is logarithmic reads and logarithmic storage for every individual key.” (“Ask about Geth: Snapshot acceleration”)

Cpp的三五零法则

Fri, 12 Sep 2025 08:50:48 +0800

三法则 The Rule Of Three

面试官： 在 C++ 编程中，我们经常听到一个叫做 “三法则 (The Rule of Three)” 的设计原则。你能用自己的话解释一下，这个“三法则”指的是什么吗？它规定了如果一个类定义了哪三个特殊的成员函数之一，那么它可能也需要定义另外两个？

回答：

“三法则”指的是，C++编程中，如果一个类中定义了下面三个成员函数之一，那么另外两个成员函数也需要程序员手动定义：
- 析构函数
- 拷贝构造函数
- 拷贝赋值运算符

这三者是一个紧密相关的整体，要么同时提供，要么同时不提供。

面试官 (追问): 很好，你知道是哪三个函数。那你能进一步解释一下，这个法则背后的根本原因是什么吗？

换句话说，为什么一个类只要自己定义了析构函数（比如，为了 delete 一个裸指针成员），就很可能也需要自己定义拷贝构造函数和拷贝赋值运算符？编译器自动生成的版本，在这种情况下会有什么问题？

回答：

当我们只定义这三个成员函数中的某一个时，剩下两个函数由编译器自动生成，而编译器生成的版本和程序员定义的版本可能存在冲突，导致一些 tricky 的错误。
不过，具体的错误和原因我也说不上来，请你补充。

面试官 (补充与解释): 这个问题的根本原因在于，一个类需要手动定义析构函数，几乎总是出于同一个目的：这个类在手动管理某种资源。

最典型的资源就是裸指针指向的堆内存。

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


class MyString {
private:
 char* data_; // 手动管理的裸指针
 size_t size_;

public:
 // 构造函数，分配资源
 MyString(const char* s = "") {
 size_ = strlen(s);
 data_ = new char[size_ + 1];
 strcpy(data_, s);
 }

 // 1. 我们必须手动定义析构函数，来释放资源
 ~MyString() {
 delete[] data_;
 }

 // 2. 但是，我们忘记定义拷贝构造函数...
 // 3. 也忘记定义拷贝赋值运算符...
};

现在，我们来看看编译器自动生成的拷贝函数会有什么问题：

Go语言学习

Tue, 09 Sep 2025 12:59:13 +0800

推荐的学习资源：

A Tour of Go: Go 官方的交互式教程，非常适合快速上手。
Go by Example: 通过大量可运行的实例来学习 Go 的各种特性。
菜鸟教程 - Go 语言教程: 中文资源，覆盖了所有基础知识点。

安装 Go 语言开发环境

安装包地址： All releases - The Go Programming Language

直接下载 goX.XX.X.windows-amd64.msi 这种命名的，适配我们的 windows 系统。

打开命令行，输入：

1

go version

如果正常输出版本号，就说明我么安装成功了。

编写第一个 Go 语言程序

在 Development 中创建 go-learning 文件夹，用 VSCode 打开。

在 VSCode 中安装 GO 语言插件。

输入下面的程序：

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Println("Hello, future Geth developer!")
}

如果能正确输出内容，那么说明我们的 Go 语言环境没有问题。

左值与右值

Tue, 09 Sep 2025 10:09:30 +0800

什么是左值？什么是右值？如何区分它们？

面试官： 在 C++ 中，我们经常听到“左值”和“右值”这两个术语。你能用自己的话，简单地解释一下，什么是左值，什么是右值吗？最简单的区分它们的方法是什么？

回答：我在一年多前的程序设计课上学过这两个概念，但现在我的记忆已经模糊，凭感觉回答一下。

左值是被持久保存而不是临时保存的值，它通常就是我们定义的变量的值。因为出现在赋值式子的左边，所以叫做“左值”。
右值是通过某些代数计算式得到的临时值，它通常出现在赋值式子的右边，因此被称为“右值”。

面试官 (补充与深化): 你说的“能否放在赋值运算符左边”是一个非常好的启发式判断方法。一个更根本的、适用于现代 C++ 的区分标准是：

我们能否对这个表达式“取地址”？

左值 (lvalue)：是一个表达式，它指向了一个具名的、有持久状态的对象或函数。我们可以对它取地址 (&)。它在表达式结束后，依然存在。
- 例子：变量名 int x; x 是一个左值，我们可以 &x。std::string s; s 是一个左值。
右值 (rvalue)：是一个表达式，它通常代表一个匿名的、即将被销毁的临时值。我们无法对它取地址。它在表达式结束后，就不复存在了。
- 例子：字面量 10 是一个右值，你不能 &10。函数返回值 get_string()（如果返回的是一个值而非引用）是一个右值。x + y 这个表达式的结果也是一个右值。

总结一下：

左值：有家（内存地址），能活得久。
右值：没家（没法取地址），是“过客”（马上就消失）。

右值引用

面试官 (引入新概念): 好的，既然我们知道了左值和右值的区别。C++11 为了配合移动语义，引入了一种新的引用类型，叫做右值引用 (rvalue reference)，用 && 表示。

1
2
3
4
5


int x = 10; // x 是一个左值
int& l_ref = x; // 左值引用 l_ref 绑定到左值 x (OK)

int&& r_ref = 20; // 右值引用 r_ref 绑定到右值 20 (OK)
// int&& r_ref2 = x; // 错误！右值引用不能直接绑定到左值

请问，&& 这个右值引用的主要设计目的是什么？它和我们之前讨论的移动语义 (Move Semantics) 是如何关联起来的？

什么是Geth？

Mon, 08 Sep 2025 22:27:55 +0800

什么是 Geth？

Geth 是 “Go Ethereum” 的缩写。

简单来说，Geth 是一个你可以下载并运行的软件程序，它能将你的计算机变成一个以太坊网络中的“节点”（一个参与者）。

它是以太坊基金会官方开发的、用 Go 语言编写的，也是目前最流行、使用最广泛的以太坊客户端。

一个简单的比喻

你可以把 Geth 想象成一个专门用于访问以太坊网络的 “超级浏览器”。

就像你需要 Chrome 或 Firefox 来连接和浏览互联网一样…
你需要 Geth 这样的“客户端”软件来连接和参与以太坊网络。

Geth 的主要工作是什么？

当你运行 Geth 时，它会开始做几件非常重要的事：

连接网络 (P2P Networking): 它会像一个社交达人一样，主动去寻找并连接到世界上其他同样在运行 Geth (或其他以太坊客户端) 的计算机，形成一个巨大的点对点网络。
同步和验证数据 (Syncing & Validating): 它会从其他节点那里下载完整的以太坊区块链账本，并从头到尾验证每一笔交易的合法性，确保没有任何人作弊。这就是为什么它需要很大硬盘空间的原因。
执行交易 (Executing Transactions): 这是它的核心工作之一。当有人发起一笔转账或与智能合约交互时，Geth 会负责处理这些交易，计算出账户余额的变化，并更新区块链的状态。这个计算过程是在一个叫做“以太坊虚拟机 (EVM)”的环境中完成的。
管理账户 (Managing Accounts): Geth 可以帮你创建以太坊账户（钱包地址），安全地管理你的私钥，并用它们来签署交易。
提供接口 (Providing APIs): Geth 会开放一个“服务窗口”（RPC API），允许其他软件（比如 MetaMask 钱包、开发工具、你自己的程序）来向它查询区块链数据（比如某个账户的余额）或提交新的交易。

总结

总而言之，Geth 是你进入和参与以太坊世界的大门和核心引擎。没有像 Geth 这样的客户端软件，以太坊网络就无法运行，因为它正是由千千万万个运行着 Geth 的节点共同组成的。

构造函数相关知识

Sun, 07 Sep 2025 21:25:43 +0800

如果没有定义构造函数——默认构造函数

面试官： 好的，我们来聊聊 C++ 的一个核心特性——构造函数 (Constructor)。

我们知道，构造函数是在创建对象时被自动调用的一个特殊函数。除了我们最常见的、带参数的普通构造函数之外，C++ 编译器在某些情况下，还会为我们自动生成一些特殊的构造函数。

我的第一个问题是：如果我们在类中没有定义任何构造函数，编译器会为我们自动生成一个什么样的构造函数？它的作用是什么？

回答：我不太了解这个问题，所以凭感觉回答，请你为我补充。

编译器自动为我们生成的构造函数不会初始化任何的成员变量，所有的成员变量都处于原始状态。
它的作用是保证对象能够生成，而不会导致报错，起到占位的作用。

面试官 (补充与解释): 你说得基本正确。如果我们在类中没有定义任何构造函数，编译器会为我们生成一个默认构造函数 (Default Constructor)。这是一个无参数的构造函数。

这个自动生成的默认构造函数，它会做什么？

它的行为比我们想象的要“智能”一点，它遵循一个规则：

对于类类型的成员 (Class-type Members)：如果这个类成员有自己的默认构造函数，那么编译器生成的默认构造函数就会自动调用这个成员的默认构造函数。

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


class Engine {
public:
 Engine() { std::cout << "Engine constructed\n"; }
};

class Car {
public:
 // 没有定义任何构造函数
private:
 Engine engine_; // 类类型成员
};

// 当你创建 Car c; 时，
// Car 的合成默认构造函数会被调用，
// 它会自动调用 Engine 的默认构造函数，
// 所以你会看到 "Engine constructed" 输出。

对于内置类型的成员 (Built-in Type Members, e.g., int, double, 指针)：

《逃避自由》读书笔记

Sun, 07 Sep 2025 15:44:49 +0800

第一章：自由——一个心理学问题

我的理解：

弗洛伊德认为历史只是由人的本能冲动塑造而成，社会的作用只是压抑人性。但是，弗洛伊德忽略了历史对人的冲动的反作用，或者说，社会的创造性，即：一些冲动并非来自本能，而是社会历史塑造的需求。
涂尔干等社会学家，以及行为心理学家，将人类视为被动的、没有内在动力的存在，认为人的本能是一个伪命题，它只是对外部环境变化的适应，对社会进程的回应，却忽略了人本身心理的力量和冲动。
两者都是片面的，不正确的。因此，弗洛姆提出，既要看到人本身的冲动（继承于弗洛伊德），又要看到社会和历史是如何塑造这种冲动的。这就是“动力心理学”，它连接了“内在的心理动力”和“外在的社会历史”。

我的理解：动态适应是对心灵更深层次的改变，而且非常复杂，对吗？

人性既非一个生物上固定不变的天生欲望冲动的集合体，亦非文化模式的毫无生机的影子，可以轻松自如地适应它；它是人类进化的产物，但也有某些固有的机制和规则。

产生了新的、被压抑的情感（如敌意），这些情感不会消失，反而会成为性格中一个活跃的、制造麻烦的因素，并可能引发新的焦虑或模糊的叛逆。

“动态适应”这个概念是理解《逃避自由》全书的钥匙。 因为弗洛姆认为，现代人之所以会“逃避自由”，正是因为他们对现代社会带来的孤独感、无力感和不确定性，进行了一次大规模的 “动态适应”。他们通过放弃自我、依附于权威或随大流的方式来获得安全感，但这种适应也扭曲了他们的性格，产生了新的心理问题。

自我保存需求：基本的生存需求。（问题：物质孤独）

精神孤独：需要和他人发生联系。

为什么害怕孤独：
- 因为人只有合作才能生存。
- 主观自觉意识：人借以认识到自己是个异于自然及他人的个体的思维能力。有所归依才能找到使命感和意义感。

我们的讨论将紧紧围绕本书的主题：即人从人与自然的原始一体状态中获得的自由愈多，愈成为一个“个人”，他就愈别无选择，只有在自发之爱与生产劳动中与世界相连，或者寻求一种破坏其自由及个人自我完整之类的纽带与社会相连，以确保安全。

怎么理解上面这段话？

人获得了自由，同时也付出了代价——原子化、孤独。确定性和安全感消失了，你必须独自面对这个世界，独自做出选择，并独自承担所有后果。这种自由带来了前所未有的孤独、焦虑和无力感。
人不可能与世界完全切断连接，因此当他获得自由之后，他还是需要作出选择以克服孤独感，而只有两条路可以走：
- 道路A（积极的自由）：“在自发之爱与生产劳动中与世界相连”
  - 这是健康、积极的出路。
  - “自发之爱”：指的是在保持自我完整和独立的前提下，与他人建立的真诚连接。它不是占有或被占有，而是一种平等的、相互尊重的结合。
  - “生产劳动”：指的是创造性的工作，是你作为独立的个人，将自己的能力和才华付诸实践，去创造、去影响世界的过程。
  - 结果：通过这条路，人既克服了孤独感，又没有牺牲自己的自由和个性。他找到了新的、更高级的安全感，这种安全感建立在他与世界的积极连接之上。
- 道路B（逃避自由）：“寻求一种破坏其自由及个人自我完整之类的纽带与社会相连，以确保安全”
  - 这是不健康、消极的出路，也是本书的书名《逃避自由》的由来。
  - 动机：因为无法承受自由的重负，所以宁愿放弃自由来换取安全感。
  - “破坏性的纽带”是什么？就是弗洛姆在书中重点分析的几种“逃避机制”，比如：
    - 权威主义：通过支配他人（虐待狂）或臣服于某个强大的权威（受虐狂），将自己与一个更大的力量融合，从而摆脱孤立的自我。
    - 破坏欲：通过摧毁外部世界来消除那种让自己感到无力的威胁。
    - 机械趋同：让自己变得和别人一模一样，融入人群，放弃思考和个性，以此来获得“我不孤单”的虚假安全感。
  - 结果：通过这条路，人虽然暂时获得了安全感，但代价是牺牲了自己的自由、独立和人格完整。他变成了一个没有灵魂的“机器人”或依附于他人的“寄生虫”。

Note

当人类从古老的束缚中解放出来、获得了现代意义上的“自由”时，这种自由也变成了一种沉重的负担，使人感到孤独和不安。为了摆脱这种重负，我们面前只有两条路：要么通过爱和创造，成长为一个更强大、更完整的独立个体（拥抱自由）；要么通过臣服和盲从，放弃自我，倒退回一种新的“不自由”状态中去（逃避自由）。

第二章：个人的出现及自由的模棱两可

“始发纽带”指的是每个人与生俱来的联结，对吗？具体的例子有什么呢？

“始发纽带”指的是，那些在我们成为独立的、与他人分离的“个人”之前，就将我们与外部世界紧密联结在一起的、与生俱来且非个人选的原始纽带。

这个概念的核心在于，它强调了一种 “前个体化” 的状态。在被这些纽带束缚时，“我”这个概念是模糊的，“我”的身份、安全感和生活轨道都由这些纽带所决定。它们是温暖的、提供保护的，但同时也限制了个人自由的发展。

例子：母婴联结、宗族/血缘联结、宗教联结、阶级联结、行会联结。

“始发纽带”就像是人类社会的 “脐带” 或 “摇篮” 。它们在人类历史的早期阶段，为弱小的个体提供了生存所必需的保护、归属感和确定性。而弗洛姆在《逃避自由》中要探讨的核心问题就是：当历史的发展（如资本主义兴起、宗教改革等）切断了这些“脐带”，把人从这个“摇篮”中抛出来，让他变成一个独立的“个人”时，他该如何面对由此而来的自由，以及自由所伴生的孤独与不安？

个体化进程：

自我力量增长。
孤独日益加深。

个人独立存在，与世界分离；与世界相比，个人觉得世界强大无比，能压倒一切，而且危险重重，由此，他产生一种无能为力感和焦虑感。只要个人不是那个世界不可分割的一部分，还没意识到个人行动的可能性和责任，他就用不着害怕。一旦成为一个个人，他就形只影单，只能独自面对世界各方面的危险和强大压力。

于是，为了克服孤独与无能为力感，个人便产生了放弃个性(individuality)的冲动，要把自己完全消融在外面的世界里。

然而，臣服并非避免孤独和焦虑的唯一方式。还有另外一种，这是唯一一种良性的不以无休止的冲突而告终的方式，即，与人和自然的自发联系。它把个人与世界联系起来，但并没有毁灭其个性，这类联系的本质体现就是爱与劳动，它植根于全部人格的完整与力量中，因而也受自我增长中存在的局限限制。

个体化进程是一个力量增长和个人人格不断完善的过程，但同时又是一个丧失与别人共有的原始共同性，同时让儿童与他人越来越分离的过程。

个体化进程需要和自我成长相适应。如果个体化程度日益加深，而某些个人和社会的原因却妨碍了自我成长，就会导致某些逃避机制的产生。

当本能的固定行为的缺乏超过一定限度时，当对自然的适应不再有强制特征时，当行为模式不再受先天的机制限制时，人便开始存在了。

始发纽带既限制了个人的发展，又使个人免受孤独和焦虑的侵扰。但是，要真正成为一个人，就必须切断始发纽带。

第三章：宗教改革时代的自由

与现代社会相比，封建社会的特征就是缺乏个人自由。封建社会早期，人在社会等级中的地位是固定的。一个人在社会地位上几乎没机会从一个阶级转变到另一个阶级。从地理位置来讲，他几乎不可能从一个镇迁到另一个镇，或从一个国家迁到另一个国家，他必须从生到死，待在一个地方，甚至连随己所好吃穿的权利都没有。

但是，尽管中世纪的人在现代意义上是不自由的，但是他既不孤单，也不孤独。由于自降生起人便在社会体系中有了一个确定的、不可变更而又无庸置疑的位置，所以他扎根于一个有机整体中，没必要也无需怀疑生命的意义。

中世纪并未剥夺个人的自由，因为“个人”尚不存在；人仍借始发纽带与世界相连。唯一使他认识到自己是个“个人”的途径便是他的社会角色（即其天然角色）。他也未视其他人为“个人”。到城里来的农民是陌生人，甚至城里不同社会群体之间的成员，也都彼此视对方为陌生人。个人自我意识、他人意识及世界意识尚未得到充分发展，尚未意识到三者是独立的实体。

资本主义解放了个人。它把人从集体制度的统治下解放出来，允许人自谋出路、自己去碰运气。人成了自己命运的主宰，他的命运便是冒险、便是获利。个人努力会使他成功，使他经济独立。金钱成了人最大的等价物，比出身门第更有力量。

个人摆脱了经济及政治纽带的束缚。他在新制度中发挥积极独立的作用，获得了积极意义上的自由。但他同时摆脱了曾给他安全感和归属感的那些纽带。生活不再是一个以人为中心的封闭世界；世界已变得无边无际，同时又富有威胁性。由于人失去他在封闭社会里的固定位置，所以也找不到生活的意义所在。其结果便是他对自己及生活的目标产生怀疑。他受到强大的超人力量、资本及市场的威胁。每个人都成了潜在的竞争对手，他与同胞的关系也敌对和疏远起来；他自由了—也就是说，他孤立无助、备受各方威胁。

天堂永远失去了，个人茕茕孑立、直面世界，仿佛一个陌生者置身于无边无际而又危险重重的世界里。新自由注定要产生一种深深的不安全、无能为力、怀疑、孤单与焦虑感。

路德派教义的心理学意义：

因信称义，但信仰是否虔诚的重担落在了自己的肩上。这是一种消极自由。
屈从于上帝的权威，将意志消融于上帝的意志之中。

这种“通过彻底贬低自我、放弃个人意志来与一个更强大的力量结合，从而获得安全感”的心理机制，正是弗洛姆所说的虐待狂-受虐狂（施虐-受虐）共生关系的雏形，也是后来权威主义性格的心理根源之一。人们为了逃避孤独的自由所带来的焦虑，选择了向一个外在的、至高无上的权威屈服。

加尔文派教义的心理学意义：

final和override关键字

Sun, 07 Sep 2025 08:53:49 +0800

关键字 `override`

没有 `override` 时存在的风险

面试官： 在 C++11 之后，我们在处理类的继承和虚函数时，多了 override 和 final 这两个说明符。我们先来聊聊 override。

请看下面这段代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Base {
public:
 virtual void doSomething(int param) { /* ... */ }
};

class Derived : public Base {
public:
 // 这里有一个小小的笔误，程序员将int写成了long
 virtual void doSomething(long param) { /* ... */ }
};

在 Derived 类中，程序员的意图是重写 (override) 基类的 doSomething 函数。但由于笔误，他把参数类型从 int 写成了 long。

请问，在没有 override 关键字的情况下，这段代码能编译通过吗？如果能，它在多态调用时，可能会产生什么样的问题？

回答：

我认为编译能够通过。由于参数列表不同（这里是参数类型不同），编译器会认为程序员在 Derived 类中重载了一个虚函数。
可能的问题：在多态调用时，会出现函数参数实际类型不一致的情况，可能导致冲突。

面试官 (补充与解释): 你说的很对。我们来把这个问题分析得更透彻一些。

是谁偷走了我的Gas？

Sat, 06 Sep 2025 10:21:41 +0800

原文地址：Maat: Analyzing and Optimizing Overcharge on Blockchain Storage | USENIX

第一遍阅读后 (5-10 分钟)

这篇文章，大概是关于什么的？

这篇文章主要讲的是作者团队开发了一个叫做 Maat 的工具，用来解决 Ethereum 中存储过度收费的问题。

这个 Maat 有三大好处：

能在更精细的颗粒度上识别存储收费情况。(fine-grained)
基于共识开发，具有节点之间的连续性。(consensus-oriented)
实现资源的预分配。(resource pre-allocation)

以及，使用 Maat 的额外开销很小，且具有扩展性。

第二遍阅读后 (约 1 小时)

【论文核心问题】：这篇文章想要解决的核心问题是？

Three overcharge issues:

Continuous access to the same object within a block
Conitnuous access to the same object across a limited number of blocks
The deployment of duplicate contracts

【它的解决方案】：作者提出的核心方法/模型是？

作者构建了一个工具：hzysvilla/Maat。它主要采用下面三种作用：

函数重载和函数重写

Sat, 06 Sep 2025 09:28:27 +0800

昨天我们聊了虚函数和多态的实现，今天我们来聊一个与它紧密相关，但在概念上又容易混淆的话题：重载 (Overloading)、重写 (Overriding) 和隐藏 (Hiding)。

这三个术语描述了 C++ 中函数名相同但行为不同的几种情况，是面试中考察“你是否能精确理解 C++ 概念”的经典问题。

Overloading 和 Overriding 的区别

面试官： 在 C++ 中，我们经常会遇到函数名相同的情况。你能用自己的话分别解释一下，什么是函数重载 (Overloading) 和函数重写 (Overriding) 吗？它们两者最主要的区别是什么？

回答：Overloading 指的是两个函数同名，但是参数列表不同的情况。

Overriding 指的是两个函数同名、参数也相同（更准确地说，函数签名完全相同），但是一个在派生类中，另一个在基类中的情况。

我认为它们的主要区别是“参数是否相同”，以及“两者之间的关系是并列（Overloading）还是继承（Overriding）”。

你的回答非常出色！直截了当，并且准确地抓住了两者最核心的区别。

重载 (Overloading): 关键在于参数列表不同 (参数个数、类型、顺序)。
重写 (Overriding): 关键在于继承关系，并且函数签名 (signature) 必须完全相同 (函数名、参数列表、const 属性等都相同)。

你的总结“关系是并列还是继承”也非常形象。重载的函数之间是“兄弟”关系，而重写的函数之间是“父子”关系。

确定多态的时机——编译器？运行期？

面试官 (补充与追问): 你说得很好。我们来把这个概念再深化一下。

重载和重写，它们分别是在哪个阶段被决定的？一个是在编译期 (Compile-time)，一个是在运行期 (Run-time)。你觉得哪个对应哪个？为什么？

这可以帮助我们理解它们更深层次的机制差异。

回答：我认为，Overloading 属于静态多态，在编译期就被确定了，因为具有 overloading 关系的两个函数只有名字相同，而函数签名不同，事实上可以被看作两个不同函数，这使得编译器可以分辨他们。（编译器在处理函数调用时，会根据传入的实参类型、数量和顺序，查找应该匹配的函数，这个过程被叫做“名字修饰”）

而对于 overriding 属于动态多态，需要在运行期才能被确定，这和我们昨天讨论的虚函数与多态相关，程序必须通过 v-ptr 和 v-table 才能确定我们调用的到底是哪一个函数。‘

面试官 (总结与肯定): 你说得对极了。

重载 (Overloading) 属于静态多态，是在编译期决定的。
- 编译器在处理函数调用时，会根据你传入的实参类型、数量和顺序，像查字典一样，去查找应该匹配哪个版本的同名函数。这个过程叫做名字修饰 (Name Mangling) 或名称改编。编译器会给每个重载函数一个独特的内部名称，所以对编译器来说，它们就是不同的函数。这个决策过程完全不需要等到程序运行。
重写 (Overriding) 属于动态多态，是在运行期决定的。

面向对象与多态

Sat, 06 Sep 2025 09:28:10 +0800

什么是多态？实现技术是什么？

看到你的简历上写着熟悉 C++ 的面向对象编程。那你能用自己的话简单解释一下，什么是多态吗？在 C++ 中，我们通常通过什么关键技术来实现多态？

我理解的多态，就是同一个函数在不同的继承类中可以有不同的内容，这取决于子类自己的实现方式。（更精炼的表达：同一个接口，不同的实现。）

实现多态的关键技术通常是虚函数 (virtual function)，即基类中声明的函数，在派生类中可以有自己另外的实现 (override)，从而适配每个派生类的具体情况。（如果基类中没有对这一函数的实现，全部靠派生类自己实现，那么这种函数就是纯虚函数）

用基类指针指向派生类对象

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


class Animal {
public:
 // 这是一个普通的虚函数，它有自己的实现
 virtual void makeSound() {
 std::cout << "Some generic animal sound" << std::endl;
 }
};

class Dog : public Animal {
public:
 // Dog 类重写(override)了父类的虚函数
 void makeSound() override {
 std::cout << "Woof!" << std::endl;
 }
};

1
2


Animal* pAnimal = new Dog(); // 用基类指针指向派生类对象
pAnimal->makeSound(); // 请问，这里会输出什么？

如果用基类指针指向派生类对象，并调用函数，那么这个函数应该是派生类中覆写后的版本，而不是基类中的版本。

即：输出结果取决于指针实际指向的对象的类型（动态类型），而不是指针变量本身声明的类型（静态类型）。

C++如何保证能调用正确的函数呢？这一点我只是依稀记得和 v-table 还有 v-ptr 相关，具体内容不记得了。

vector的内部实现和优化

Sat, 06 Sep 2025 09:27:46 +0800

`vector` 在内存中如何存储数据？和 `array` 的区别？

面试官： 我看你写的代码里经常使用 std::vector。你能简单描述一下 std::vector 在内存中是如何存储数据的吗？它和普通的 C 风格数组（比如 int arr[10]）有什么主要的区别？

回答：

对于这个问题，我并不太了解，我谈一谈我粗浅的看法。
首先，vector 应该是基于数组 array 实现的，其底层就是一块动态分配的、连续的内存数组。这是 vector 能够支持快速随机访问的根本原因。但是，vector 肯定有它自身的优化在。
边界检查：
- array 只管给你分配一段连续的内存，其他的管理你都要自己来，也不会管你数组 idx 是否越界；
- 在 vector 中，如果用 [] 操作符，那么行为和 array 一样，不会管你越界与否；
- 但是，vector 提供了 at() 这个成员函数，vec.at(i) 会进行边界检查。如果 i 越界，vector 会抛出 std::out_of_range 异常。这说明 vector 的安全性更好。
自动初始化：
- 再比如，定义 array 时，程序不会帮我们自动初始化，array 中可能有一些奇怪的原始数据（随机值）；
- 但是，定义 vector 时，程序会帮我们自动初始化。

不过，我没有提到 vector 和 array 最重要的区别：（根据 Gemini 的解释补充）

Vector 的大小是动态可变的，可以不断地 push_back 新的元素，而 array 的大小是固定的。
这就是 vector 的动态扩容机制。

`vector` 的扩容机制 (Reallocation)

面试官 (补充与追问): 你说得很好。vector 最大的特点就是它的大小是动态可变的。我们可以不断地对它 push_back 新的元素。

Cpp内存管理

Sat, 06 Sep 2025 09:27:23 +0800

Cpp 内存分区

你能简单介绍一下 C++ 程序的内存分区吗？一个 C++ 程序在运行时，它的内存大概被分成了哪几个区域？

回答：

Cpp 程序运行时，分成堆、栈，以及全局的静态区域。
栈中的数据在函数调用结束时，就自动被释放。
堆中的数据由程序员自己分配，自己释放。
全局的静态区域在整段程序结束时，自行释放数据。

请问，我的理解正确吗？

基本正确，但还需要补充：

面试官 (补充与细化): 你说的完全正确。为了让这个回答更完整、更专业，我们通常会把内存分区说得更细一些，一般分为五个区。你提到的三个区是其中最重要的，我帮你补充另外两个。

一个典型的 C++ 程序内存布局：

栈区 (Stack)：
- 存放：函数的参数值、局部变量等。
- 管理：由编译器自动分配和释放。
- 特点：函数调用时入栈，函数返回时出栈，分配速度快，但空间有限且是连续的。
堆区 (Heap)：
- 存放：程序运行时动态分配的内存，比如通过 new 或 malloc 创建的对象。
- 管理：由程序员手动分配 (new) 和释放 (delete)。如果忘记释放，就会造成内存泄漏。
- 特点：空间大，不连续，分配和释放速度相对较慢。
全局/静态存储区 (Static Storage Area)：
- 存放：全局变量和静态变量 (包括全局 static 变量和函数内 static 变量)。
- 管理：在程序编译时就已经分配好了，在程序整个运行期间都存在，程序结束时由操作系统释放。
常量存储区 (Constant Storage Area)：
- 存放：常量，特别是字符串常量 (e.g., "hello world")。
- 特点：内容只读，不允许修改。
代码区 (Code Area / Text Segment)：
- 存放：编译后的二进制机器代码。
- 特点：只读，且可共享。

你能把这五个区记住，在面试时就能给出一个非常全面和专业的回答。

堆和栈的对比

面试官 (深入提问): 好的，你对内存分区已经很清楚了。我们来聚焦于堆 (Heap) 和栈 (Stack) 的对比。

C++的三种访问权限修饰符

Sat, 06 Sep 2025 09:21:34 +0800

成员访问的三种权限

面试官： 在 C++ 的类（class）定义中，我们有 public, protected, 和 private 这三个关键字来控制成员的访问权限。

你能简单解释一下，这三种权限分别意味着什么吗？也就是说，什么样的代码可以访问被它们修饰的成员？

回答：

public 修饰的成员，可以被该类的对象、该类的子类成员，以及该类的其他成员访问。（最宽松）
private 修饰的成员，只能被该类的其他成员访问，而不能被对象和子类成员访问。（最严格）
protected 修饰的成员，可以被该类的其他成员和子类的成员访问，但不能被该类的对象访问。（介于 public 和 private 之间）

Gemini 更好的概括：

public: 类内、子类、类外（通过对象）都能访问。权限最开放。
private: 仅限类内访问。权限最严格，实现了完全的封装。
protected: 类内、子类可以访问，但类外不行。权限介于两者之间，专门为继承体系设计。

类继承的三种权限

面试官 (深入提问): 好的，你对成员访问权限很清楚。现在我们把这个概念和继承结合起来。

C++ 中，继承也有三种方式：public 继承、protected 继承和 private 继承。

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


class Base {
public:
 int public_member;
protected:
 int protected_member;
private:
 int private_member;
};

class Derived_Public : public Base { ... };
class Derived_Protected : protected Base { ... };
class Derived_Private : private Base { ... };

请问，这三种不同的继承方式，会如何影响基类 (Base) 的成员在派生类 (Derived) 中的访问权限？

explicit关键字

Sat, 12 Jul 2025 10:35:00 +0000

好的，我们来深入解析 explicit 这个虽小但非常重要的关键字。

你的理解完全正确！explicit 关键字就像一个“门卫”，它守在你的构造函数门口，防止一些“不请自来”的隐式类型转换，从而让代码的行为更加清晰、可控。

一、问题根源：什么是构造函数的“隐式转换”？

在 C++ 中，编译器有时候会“自作主张”地帮你进行类型转换，让代码能够通过编译。如果一个类的构造函数可以只用一个参数来调用，那么这个构造函数就可能被编译器用来进行隐式转换 (Implicit Conversion)。

让我们来看一个没有 explicit 的“事故现场”：

场景设定：我们有一个字符串类 MyString，它有一个构造函数，可以接受一个整数 n 来创建一个由 n 个 'A' 组成的字符串。

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


#include <iostream>
#include <string>

class MyString {
private:
 std::string m_str;
public:
 // 这个构造函数可以用一个 int 参数来调用
 MyString(int n) : m_str(n, 'A') {
 std::cout << "MyString(" << n << ") 被调用了！\n";
 }

 const char* c_str() const { return m_str.c_str(); }
};

// 这是一个希望接收 MyString 对象的函数
void printString(const MyString& s) {
 std::cout << "打印: " << s.c_str() << std::endl;
}

现在，在 main 函数中，我们可能会写出这样的代码：

线上线下——一个线下社恐的思索

Tue, 03 Oct 2023 22:00:00 +0800

2023 年 10 月 3 日

今天，是我一个人呆在家的第四天。这几天，我几乎要把头埋到社交软件里了。

有的时候，社交软件真的能给人带来奇特而有趣的体验：或许，线下你待人羞羞答答，唯唯诺诺，不敢高声语，不敢放肆谈，即便一个眼神相接，也要匆忙躲闪，或是报以不失礼貌的微笑，若是一句话说出来冷场，空气里的尴尬仿佛都要凝成大雨落下，给你从头浇到脚；但是，线上的你，却能巧舌如簧，打字如飞，发言幽默又不失优雅，就算偶有尴尬，也都被屏幕间的阻隔消弭于无形，或者，用沙雕表情包和对方一起“哈哈哈哈哈哈哈”就完事了。你看，有了网络如此“神兵利器”，就连《人生海海》中的小瞎子也能摇身一变，成为五湖四海网友的人生导师。如此看来，线上社交，好处自是不必说了。

可是，看着熟悉的头像、闪烁的图标，看着聊天框右侧的红点，看着不断更新的 QQ 空间或是朋友圈，当我听到振动声而本能地伸手向手机的一刹那，为什么我总觉得少了点什么？

少了点什么呢？

大英老师推荐美剧《老友记》，今天闲极无聊时看了看。那是 1994 年就开始播送的情景剧，距今将近 30 年了，那时还没有智能机，没有如此发达的社交软件，朋友们的关系仍主要靠线下交流维持。虽说只看了寥寥几集，而且以搞笑为主，但这部剧仍给了我不少关于友情的感动。我想，这种令人感动的友情是线上的交流难以企及的。

当你喜不自胜时，TA 可以抱住你一起傻乐呵，一起大喊大叫；当你悲从心来时，TA 可以握住你的双手，和你一起默默流泪；你说的每一句话不再是冷硬的文字，而是配上了神态、动作、语气的，丰富又独一无二的宝藏，而不是被网络同质化的、量产的所谓“梗”或是“表情包”；你在面对面的交流中，也许不经意间，就显露了在网上有意无意隐藏着的一面……这些是人与人之间真正的联结。

当我沉溺于社交软件时，我既期待又空虚：我期待他人的每一条回复，我期待对方的善意，同时期待表达自己的善意，可是等待是折磨人且空虚的，当我一次次划开手机，却无事发生时，我不由自主地会感到孤独，而更迫切地渴望线上的联结。但是，始终在线上交流，始终隔了一层屏幕，就像始终戴了一张面具，或者说，一层“可悲的厚障壁”。在一个已经存在 AI 可以和人类正常交流的时代，我觉得单纯的线上交流总有点缺乏人性的温度。（或许，等到能够仿生 100%的机器人出现了，我就不会再说所谓“人性的温度”这样的短语了吧？）

然而，当线下交流的机会真的摆在眼前，许多人又会犹豫。毕竟，线上的“见面”可以随时随地（只要你还有流量），而线下的见面也许要奔波百千里；线上的发言可以字斟句酌，而线下的交流却是即时互动；线上的分别很短，短到互道“去睡了”的人可以在几分钟之后于峡谷相遇，而线下的分别，也许就是古人的“此去经年”或者“动如参与商”……何必来到线下加深联结？现代人来去匆匆，做一株无根的浮萍不好吗？

所以，你选择线上，还是线下？

永是有情人

Sat, 30 Sep 2023 22:00:00 +0800

2023 年 9 月 30 日

只要没有感情，人是怎样互相联系都可以的。

一场突如其来的雨，浇透了他的青春；一把出乎意料的伞，撑起了他的心灵。从此，他开始了一段苦苦追寻的旅程。

他给你的印象常常是忧郁的，只是不做任何表情，就能看出他内心的沉重与哀伤，但那不是全部——在他偶尔开怀大笑的时候，你是不会忽略他蓬勃的生命力的。

曾以为，你和他是一路人，某个渺渺茫茫的目标，骗得你们走过山一程水一程，骗得你们在深夜辗转难眠，骗得你们无数次以为自己失去梦想又无数次站起，继续走向不可知的未来。一开始你们只是聊感情，聊自己的坚持，聊对方的执着，然后彼此嘲笑，互相宽慰，似乎这样就能解决烦恼。多少还是有点作用吧，因为你们看到了，自己不是一个人。

其实，你们并不一样。你只是希求他人的认同，而他在渴望某个人纯粹而恒久的爱，并愿意为之付出一生。你觉得他幼稚：在当下的社会，寻求一段古典式的爱情，就像是在泥石流中寻觅清泉一般，要么同流合污，要么自我消亡。可是，难道你就能说对此你没有丝毫的羡慕或是尊敬吗？幼稚可以假扮伟大，伟大的行为有时同样会披上幼稚的外衣，因为”成熟“与“幼稚“在许多时候都只是社会的定义。而且，有些时候，你比他还要幼稚——你能看清楚某些事，却总是做不到。

你总是在两极徘徊，或寂寞，或冷漠，或既寂寞又冷漠，自己为难自己，最终只能压抑欲望，潦草收场；他则有一股子痴心，说自己是“绛珠仙草”，这辈子的眼泪总得为别人流尽了，但却不说后悔，只愿那人平安喜乐。这是你羡慕他的地方之一——不求上进却又通达，像是喷薄而出的地火冷却成玄武岩，满是孔洞，又坚硬纯粹，应足以守护所爱。

你只有被爱和被承认的渴望，而他可谓钟情者，有情人。他会在夜晚的人群中高歌，会将低垂的月轮比作盈满泪水的眼眶，会坦诚地和你分享奇特的梦境，会陪着你走过操场，一圈又一圈，会突然和你说“我感觉到了”，然后在下一个拐角遇到他的意中人……

“只要没有感情，人是怎样互相联系都可以的。”相对地，如果人想怀着感情，与他人建立联系，那就得做好受伤的准备。起码到现在为止，你想，你是没有做好准备的，于是在某种意义上变得“无情”；而有情的他，似乎早已做好准备，也许就在多年前的某个夜里，也许就在直面结果虚无的一刹那。

你希望，他，永是有情人。

摔倒了，阁下该如何应对？

Sat, 23 Sep 2023 22:00:00 +0800

2023 年 9 月 23 日

今天下午，我骑车摔倒了。

其实站起来的时候，身上并没有多疼，直到我看到了伤口，才意识到问题没那么简单：四肢多处擦伤，下巴磕破了皮，右膝也摔出淤青，但最严重的还是直接着陆的右手肘——伤口很深，殷红的血液混着黑灰又泛光的积水，绘成奇诡的画卷。我感觉自己比想象中冷静，到了医院之后，一边流着止不住的血，一边问路、挂号、拍片、签字、付钱、进手术室、出手术室、抓药、给病假单盖章、打车到校门口……除了送医院是保卫处帮忙开的车，剩下的一切居然都是我自己完成的。

值得一提的是拍片和手术这两个环节。

因为要鉴定骨伤程度，所以每个受伤的部位都得拍片，都得在冰冷的 CT 台（其实我不知道那个大铁台的名字，姑且这么称呼）上左挪右挪，于是阴暗的房间里，鲜红滚烫的血就在一派灰银上四处“乱晃”，甚至有一滴直接落到了地板上，炸出一朵血花，但看着护士面不改色，轻轻拿起纸巾，擦掉了所有血迹，我也“不好意思”再害怕地说这说那。

后来好不容易摸到二楼，想着总算可以处理流血不停的伤口了，我却看见面前门上的三个大字——“手术室”。天真的我，以为伤口只要消毒即可，结果医生告诉我“一块肉都没了，得缝好几针”。紧接着我脱口而出的三个字就是——疼不疼？那医生笑笑，说会打麻药，不疼的。结果确实是不疼，但是，那种清醒时模糊地感觉到有人在切割、缝补自己血肉的经历，我真的不想再经历。我不想被缝补，当然也不想替他人缝补。那位医生干活时还能和同事谈笑风生，聊起三点半下班之后吃什么，是令我十分敬且畏的。这也是我为什么不想学医的一大原因。

其实最令我头疼的事情，是在所有都结束之后，发现自己每天要吃两粒头孢，给其他伤口涂碘伏，两天要换一次纱布，十四天之后要再来拆线，而且不能跑步、不能洗澡、右手不能使力，不能过于弯曲这意味着，写作业、吃饭、洗衣服、刷马桶、倒垃圾等一切习以为常的事情都变得相当有挑战性。当你失去了一半的行动能力，你才发现平时的生活变得多么可贵。

所以我不禁会想：要是今天没有下雨就好了，要是我能早点出发就好了，要是导航没有出错就好了，要是我根本不去那个无聊的讲座就好了，要是我骑车的时候把外套穿上就好了，要是我骑的是山地车而非共享单车就好了……起码不会摔得这么狼狈，令人看到不禁要发笑。我自己也笑自己——那么多的“要是”，撞在了同一天，那么摔倒或许就是命中注定的缘分。

印象里，类似的摔倒还有三次。

一次在幼儿园，摔在楼梯上滚落而下，同样是磕了一个洞，同样缝了几针，只不过是在额头上，最后留了一个浅浅的疤；一次在小学一年级，在家门口一跤摔断了右手手腕，被迫用左手学习写字；一次在小学四年级，进校门时的一跤磕断门牙，从此笑容中总是有一抹暗淡的色彩。

摔倒总是在最想不到的瞬间出现，打乱你生活的所有安排，然后似启发、似挑衅地问道：“现在，阁下又该如何应对？”

所以，该如何应对呢？摔倒了该如何应对呢？联赛的第一题就不会做该如何应对呢？高考前彻夜难眠该如何应对呢？动车晚点两小时，来不及赶赴一场重要的宴会该如何应对呢？喜欢的人说要离开该如何应对呢？和梦校擦肩而过该如何应对呢？……

我不知道答案。可能我也不需要知道答案。

Mon, 01 Jan 0001 00:00:00 +0000

终于学习到面向对象的设计思想了吗？不容易啊！

Item32: Make sure public inheritance models “is-a”

public inheritance 的实际含义就是“is-a”。

“If you write that class D (“Derived”) publicly inherits from class B (“Base”), you are telling C++ compilers (as well as human readers of your code) that every object of type D is also an object of type B, but not vice versa.”

子类公共继承了父类，实际上就是在说，子类的某个对象，在逻辑上也是被包含在父类中的。子类是父类的特化，父类是子类的泛化。

在一切需要使用父类对象的时候，使用子类对象也一定是合法的——因为子类对象在逻辑上同时也是父类的对象。

父类有的特征（成员），子类一定有（但不能直接访问父类的 private 成员）；子类有的特征（成员），父类通常没有。

不要被直觉误导，自然语言的表述是不准确的：

“鸟会飞”指的是“大部分鸟会飞”，而不是“所有鸟都会飞”。
如果我们要写一个 Bird 类，那么我们不能将 fly() 定义为 Bird 类中的纯虚函数，因为 fly() 不是所有鸟类共有的特征。

继承其实远比我们想的复杂：有些事情，可以对基类做，但是不能对派生类做，但 public inheritance 的语义是“所有对基类能做的操作，一定能对派生类做”。这就很麻烦了。

Hello! on Mao's Blog

明天还是有雨

为什么我不喜欢CS3321数据库技术？

成长是逐渐摆脱自恋的过程

总有人坚定，总有人相信

除夕火

一棵树在森林倒下

从南大门到庙门

执念如谜

前世劫与今生缘

有家可回真好

5-Implementations

Item26: Postpone variable definitions as long as possible

不知道去哪也挺好

坚持练习 100 天八段锦，我的身体发生了哪些变化？

4-Designs and Declarations

Item18: Make interfaces easy to use correctly and hard to use incorrectly

参数顺序容易搞混吗？

3-Resource Management

Item13: Use objects to manage resouces

手动管理资源的做法

RAII 的做法

2-Constructors, Destructors, and Assignment Operators

Item5: Know what functions C++ silently writes and calls

1-AccustomingYourselfToC++

Item1: View Cpp as a federation of languages

Item2: Prefer consts, enums and inlines to #define

Cpp八股面试题

智能指针相关

回家两周，杀戮尖塔治好了我的精神内耗

SFINAE原则

SFINAE (Substitution Failure Is Not An Error)

什么是 SFINAE？

场景重现：编译器的选秀大会

RAII设计哲学

RAII: Resource Acquisition Is Initialization

命名空间

命名空间 namespace

C++类型转换符

static_cast 转换符

default和delete

default 关键字强制生成默认构造函数

虚析构函数

不使用虚析构函数，可能导致资源泄漏

Const关键字

const 修饰变量

const 与指针结合

new运算符的细节

new 的两步过程、定位 new 操作

栈、堆与栈溢出

栈和堆的比较 Stack and Heap

栈溢出 Stack Overflow

模板：template和typename

模板的作用与分类

模板实例化 Template Instantiation

using关键字

using 声明和 using 指令

inline内联函数

inline 的好处与坏处

inline 的语法作用——解决 ODR 违例问题

委托构造函数

委托构造函数 Delegating Constructors

NULL和nullptr

nullptr 解决函数重载的二义性

Cpp异常处理机制

栈展开

Cpp字符串处理

std::string 的优点

Cpp的三种类型推导关键字

auto 关键字

Lambda表达式

什么是 Lambda 表达式？

Lambda 表达式的捕获列表

Geth的Snapshot机制

State in Ethereum 以太坊组织数据的方式

Cpp的三五零法则

三法则 The Rule Of Three

Go语言学习

安装 Go 语言开发环境

编写第一个 Go 语言程序

Item2: Prefer `consts`, `enums` and `inlines` to `#define`

`static_cast` 转换符

`default` 关键字强制生成默认构造函数

`const` 修饰变量

`const` 与指针结合

`new` 的两步过程、定位 `new` 操作

`using` 声明和 `using` 指令

`inline` 的好处与坏处

`inline` 的语法作用——解决 ODR 违例问题

`nullptr` 解决函数重载的二义性

`std::string` 的优点

`auto` 关键字

关键字 `override`

没有 `override` 时存在的风险

【论文核心问题】：这篇文章想要解决的核心问题是？

【它的解决方案】：作者提出的核心方法/模型是？

`vector` 在内存中如何存储数据？和 `array` 的区别？

`vector` 的扩容机制 (Reallocation)