[在线/原创/小说]告白递归栈溢出。[yehyuni][短篇]

【2025春】 [小短篇/骨科]

告白递归栈溢出

Confess::callback() && Graduate::state in recursiveLoop(stackOverflow, thread::migrate())

响应文学区2025年春季活动而作的实验性小短篇。
参加常规关卡和附加挑战。
已完结。
很显然，程式码在文学区并不是什么重要的东西，我也不会在意其中的弯弯绕绕。如果您仅仅将其看做一种表现形式当然是最好了。对其的捉虫也是欢迎的。

注释

什么是递归 (Recursion，台译递回)？
递归是指一个函数自己调用自己来解决问题的方式。就像你让一个任务分解成更小的相同任务，直到问题简单到可以直接解决。想像你在数一叠纸：你数一张，然后把剩下的交给自己再数，直到没纸为止。在程式中，recursiveLoop 函数不断调用自己，增加 depth，直到达到 maxDepth。

什么是栈溢出 (Stack Overflow，台译堆叠溢位)？
栈溢出是指电脑记忆体中用来储存函数调用资讯的「栈」(Stack) 用满了。通常发生在递归太深时，因为每次函数调用都会占用栈空间。如果你无限循环，或者设定的 maxDepth 太大，栈空间会被塞满，程式就会崩溃。

NFT标识码0x7aF9b3eC2d8f91c4aB6eD5f8e39cC4d1F92eA741 : 483920174，这是一个40字元的十六进制字串，以0x开头，表示NFT所属的合约位置。乙太坊上每个NFT系列都有一个这样的地址。483920174是标识这个合约中具体NFT的唯一token ID。当然我不建议您在Etherscan上验证这串虚构的标识码，因为这是无意义的。

2025年3月17日

似乎，是一场梦。

毕业的疲惫如潮水般涌来。上学也好毕业也好都很累。事到如今，毕业就是毕业了，面对前路坎坷如同一滩烂泥般的未来，我有什么办法。

好烦啊！！！

在欢声笑语的校园步道里走着。

和在校门留影的毕业生们擦肩而过。

和回到社团与学弟学妹作最后告别的毕业生们擦肩而过。

和嬉笑打闹的情侣毕业生们擦肩而过。

烦躁到妹妹溜到我身边了也没察觉到。

直到感觉到有一只手在我面前反复while(true)晃动，努力调试我的视线焦点时，我才注意到身旁的娇小身影。

「姊姊，恭喜妳毕业啦！」

清脆地声音如同清泉滴落时苔石时的回馈，向我发出祝贺的是我的亲妹妹。

不过，她比我要小两岁，所以与穿着毕业服饰的我不同，尚未触及毕业这道指令，身上还是一如往常的校服打扮。修短的百褶裙随风摇曳，胸口的蝴蝶结始终保持着微妙的歪度，使之既不失端庄又微妙地透出白皙的风光。正是这个年龄少女流行的参数调校。我回答她道：

「是啊，毕业了。」

「三月份毕业就是好诶！有种生机勃勃的感觉！」

妹妹的语气镶嵌着雀跃，像是宣告一个成功的return spring；听罢，我的眼神下意识地开始穿越熙熙攘攘的人群，徒劳地寻找妹妹口中所谓春日的感觉。可惜我们学校不种樱花——并不是说没有五彩缤纷的春花绽放，只是有种对樱花必须堆叠压满毕业季的近乎执念的掌控欲，但实在没有也没办法。我又下意识地轻叹一声继续前进，妹妹则紧跟在我身旁。

「姊姊是在找樱花吗？」

「是啊…妳怎么知道吗？」

「姊姊，我喜欢妳。」

心脏漏跳了一拍。吃惊的我转过身去看向面颊上染上绯红的妹妹。

「姊姊，妳可能有点惊讶吧，但是我说这话也是很害羞的。因为毕业了才想着这是最后的机会…」

#include<iostream>
#include <string>
#include<chrono>
#include <thread>

class MemoryStack{
private:
std::string currentScene;
boolisOverflow;

public:
MemoryStack() :currentScene(“初始記憶”),isOverflow(false) {}

void pushScene(const std::string&scene) {
if (!isOverflow) {
currentScene =scene;
std::cout << “[Scene Updated]: “<< currentScene << “\n”;
} else {
std::cout << “[Stack Overflow]:記憶溢出，無法推送新場景\n”;
}
}

void confessCallback() {
std::cout << “妹妹:「姊姊，我喜歡妳。」\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));// 模擬心跳停頓
std::cout << “姊姊:(心跳溢出…)\n”;
std::cout << “妹妹:「姊姊，妳可能有點驚訝吧……其實我說這話也很害羞。因為畢業了，我才覺得這是最後的機會，程式跑完最後一圈必須得把這句話push出去，不然就真的卡死了。」\n”;
}

void rewindTime() {
std::cout <<“[Time Rewind Triggered]: 時間開始回溯…\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1500));// 模擬回溯過程
currentScene = “2025年3月17日，似乎，是一場夢。”;
std::cout << “[Rewind Complete]: ” <<currentScene << “\n”;
}

voidrecursiveLoop(int depth, int maxDepth) {
if (depth >=maxDepth) {
std::cout << “[Stack OverflowDetected]: 告白記憶過載，觸發時間回溯\n”;
isOverflow = true;
rewindTime();
return;
}

pushScene(“畢業的疲憊如潮水般襲來…”);
std::cout << “深度”<< depth << “: 姊姊走在校園步道，妹妹悄然靠近…\n”;
if (depth == maxDepth – 1) {
confessCallback();// 告白觸發
}
recursiveLoop(depth + 1, maxDepth); // 遞迴繼續
}
};

int main() {
std::cout << “【2025春】告白遞迴棧溢出\n”;
MemoryStack timeline;
timeline.pushScene(“2025年3月17日，似乎，是一場夢。”);

// 模擬故事推進到告白，然後回溯
timeline.recursiveLoop(0, 3); // 設定最大深度為3，模擬場景推進

return 0;
}

2025年3月17日

似乎，是一场梦。

毕业的疲惫如同潮水般漫過胸膛…上学的倦怠感简直如影随形。面对人生转折点上泥泞般黏稠而混沌的未来，真让人感慨怎么还没跑满青春的进程就exit(graduate)了。记得毕业的几天前我和隔壁班上的我的好朋友抱怨时，她还笑着对我说：「这还真是妳一如既往的风格呢！毕业后也要记得联络啊！」

我的风格究竟是什么来着？坐视着旁人用汗水和时光堆叠起的青春资料，但对于平庸的少女来说其无非事不关己的浮点般漂浮，始终无法嵌入我的内核模组。

好累。

我拖着不太积极的步伐在校园的欢声笑语间挪动。连亲妹妹的娇小身影悄然滑至身侧都未曾察觉到。

「姊姊！恭喜妳毕业啦！」

「呜哇！」

受到惊讶的我扭头看向得意洋洋的妹妹。

「妳…妳怎么在这里？」

「这又是什么话？我是来庆祝姊姊毕业的呀！」

妹妹将手上的捧花递给我。色彩相得益彰的春花们簇拥在一起，契合着毕业季生意盎然的场景。然而，我捧着手上的花左顾右盼，仔细端详却怅然若失。总觉得遗漏了什么关键色块。

啊，我知道了，缺少那抹嫩粉的樱色。三月、水手服、写有卒业式字样的白色木板、手中盛放卒业证书的丸筒（まるづつ），最后必不可缺的则是漫天飞舞的樱花。见到我触景生悲的样子，妹妹摇动着裙摆，有些没好气的样子：

「毕业了呀——姊姊要开心一些好不好！已经是大人了喔，可以自由自在地做自己想做的事情了！」

想做的事情吗…

大脑仍在缓存未清除状态的我情不自禁地整理好妹妹胸前的蝴蝶结和领子，她总是不喜欢把蝴蝶结戴得规规矩矩的。妹妹不太顺从地嘴里发出「嗯嗯」的抗议声。

「姊姊不要总是这样，我又不是小孩子…」

「我是不懂妳怎么想的啦，但是稍微注意下仪容好不好。」

妹妹有些不好意思地说：

「我知道。其实我今天是故意戴歪的呀。」

「什么意思？」

「因为，姊姊毕业后就不能帮我整理蝴蝶结了。」

「诶…」

我看向妹妹。调整好蝴蝶结的我妹妹迅速调整好姿势站在我的面前，脸上也变得通红一片。

「其实、其实我喜欢姊姊很久了！」

虽然我知道妹妹对我抱有好感，但我不明白这句话的含义，仅仅是搞姊妹情深可没必要这么正经哦。但迟钝的我随后才想到，妹妹也许是其他的意思。

诶？哪个意思？

心跳瞬间溢出，如同递归函数未设终止条件，栈溢出的警报在胸腔内响鸣。我惊愕地望向眼眶湿润的妹妹。

「请姊姊和我交往吧！因为，毕业是最后的机会了…」

#include<iostream>
#include <string>
#include<chrono>
#include <thread>

class MemoryStack{
private:
std::string currentScene;
boolisOverflow;
int cycleCount; // 新增循環計數器

public:
MemoryStack() : currentScene(“初始記憶”),isOverflow(false), cycleCount(0) {}

void pushScene(conststd::string& scene) {
if (!isOverflow) {
currentScene = scene;
std::cout << “[SceneUpdated]: ” << currentScene << “\n”;
} else {
std::cout << “[StackOverflow]: 記憶溢出，無法推送新場景\n”;
}
}

void confessCallback(int cycle) {
if (cycle == 1) {
std::cout << “妹妹:「姊姊，我喜歡妳。」\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //模擬心跳停頓
std::cout << “姊姊:(心跳溢出…)\n”;
std::cout << “妹妹:「姊姊，妳可能有點驚訝吧……其實我說這話也很害羞。因為畢業了，我才覺得這是最後的機會，像程式跑完最後一圈必須得把這句話push出去，不然就真的卡死了。」\n”;
} else if (cycle == 2) {
std::cout <<“妹妹:「其實、其實我喜歡姊姊很久了！」\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //模擬心跳停頓
std::cout << “姊姊:(心跳再次溢出，遞迴未設終止條件…)\n”;
std::cout << “妹妹:「請姊姊和我交往吧！因為，畢業是最後的機會了……」\n”;
}
}

void rewindTime() {
std::cout<< “[Time Rewind Triggered]: 時間開始回溯…\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1500));// 模擬回溯過程
currentScene = “2025年3月17日，似乎，是一場夢。”;
std::cout << “[Rewind Complete]: ” <<currentScene << “\n”;
cycleCount++; //增加循環次數
}

void recursiveLoop(int depth, int maxDepth, intcycle) {
if (depth >= maxDepth) {
std::cout << “[Stack Overflow Detected]:告白記憶過載，觸發時間回溯\n”;
isOverflow = true;
rewindTime();
isOverflow = false; // 重置溢出狀態以進入下一個循環
return;
}

if (cycle == 1) {
pushScene(“畢業的疲憊如潮水般襲來…”);
std::cout << “深度”<< depth << “: 姊姊走在校園步道，妹妹悄然靠近…\n”;
} else if (cycle == 2) {
pushScene(“畢業的疲憊如潮水般漫過胸膛…”);
std::cout << “深度”<< depth << “: 姊姊拖著步伐，妹妹捧著春花出現…\n”;
}

if (depth == maxDepth – 1) {
confessCallback(cycle); // 根據循環次數觸發不同告白
}
recursiveLoop(depth + 1, maxDepth, cycle); //遞迴繼續
}

int getCycleCount() const { return cycleCount;}
};

int main() {
std::cout << “【2025春】告白遞迴棧溢出\n”;
MemoryStack timeline;
timeline.pushScene(“2025年3月17日，似乎，是一場夢。”);

// 第一個循環
std::cout << “\n=== 第一循環開始===\n”;
timeline.recursiveLoop(0, 3, 1);

// 第二個循環
std::cout << “\n=== 第二循環開始===\n”;
timeline.pushScene(“2025年3月17日，似乎，是一場夢。”);
timeline.recursiveLoop(0, 3, 2);

std::cout <<“\n[Total Cycles]: ” << timeline.getCycleCount() <<“\n”;
return 0;
}

2025年3月17日

似乎，是一场梦。

头痛欲裂。

精神如同被淹没在水中。但是，淹没我的是「毕业的疲惫」。我不知为何倒在地上看着天空中缓缓漂移的云絮。毕业季，形形色色的同学从我的身旁走过。

啊…手脚失去响应了。怪不得起不来。

毫无征兆地，妹妹出现在我视野的一角。我說：

「诶…是妹妹啊。抱歉呢，姊姊躺在这里，等会就会被赶走的吧。只是我也不知道怎么回事。」

微笑如往常般明亮的妹妹开口说道：

「Warning！Critical error occurred.」

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <stdexcept>

class MemoryStack {
private:
std::string currentScene;
bool isOverflow;
int cycleCount;

public:
MemoryStack() : currentScene(“初始記憶”), isOverflow(false), cycleCount(0) {}

void pushScene(const std::string& scene) {
if (!isOverflow) {
currentScene = scene;
std::cout << “[Scene Updated]: ” << currentScene << “\n”;
} else {
std::cout << “[Stack Overflow]: 記憶溢出，無法推送新場景\n”;
}
}

void confessCallback(int cycle) {
if (cycle == 1) {
std::cout << “妹妹: 「姊姊，我喜歡妳。」\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << “姊姊: (心跳溢出…)\n”;
std::cout << “妹妹: 「這是最後的機會，像程式跑完最後一圈……」\n”;
} else if (cycle == 2) {
std::cout << “妹妹: 「其實我喜歡姊姊很久了！」\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << “姊姊: (心跳再次溢出…)\n”;
std::cout << “妹妹: 「請姊姊和我交往吧！因為，畢業是最後的機會了……」\n”;
}
}

void rewindTime() {
std::cout << “[Time Rewind Triggered]: 時間開始回溯…\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(1500));
currentScene = “2025年3月17日，似乎，是一場夢。”;
std::cout << “[Rewind Complete]: ” << currentScene << “\n”;
cycleCount++;
}

void recursiveLoop(int depth, int maxDepth, int cycle) {
try {
if (depth >= maxDepth) {
std::cout << “[Stack Overflow Detected]: 告白記憶過載，觸發時間回溯\n”;
isOverflow = true;
rewindTime();
isOverflow = false;

// 第二次回溯後模擬異常
if (cycleCount == 2) {
std::cout << “\n=== 第二次回溯後嘗試載入 ===\n”;
pushScene(“畢業的疲憊如潮水般淹沒…”);
std::cout << “姊姊被載入校園步道，準備與妹妹見面…\n”;
throw std::runtime_error(“[Critical Error]: 未知異常，記憶體崩潰！”);
}
return;
}

if (cycle == 1) {
pushScene(“畢業的疲憊如潮水般湧來…”);
std::cout << “深度 ” << depth << “: 姊姊在校園步道與妹妹見面…\n”;
} else if (cycle == 2) {
pushScene(“畢業的疲憊如潮水般漫過胸膛…”);
std::cout << “深度 ” << depth << “: 姊姊再次在校園步道與妹妹見面…\n”;
}

if (depth == maxDepth – 1) {
confessCallback(cycle);
}
recursiveLoop(depth + 1, maxDepth, cycle);
} catch (const std::runtime_error& e) {
std::cout << e.what() << “\n”;
std::cout << “[System Crash]: 程式強制重啟中…\n”;
std::this_thread::sleep_for(std::chrono::milliseconds(2000));
forceReset();
}
}

void forceReset() {
std::cout << “[Force Reset]: 重啟完成，場景遷移…\n”;
currentScene = “2025年3月17日，畢業典禮剛結束，無人的學校禮堂。”;
isOverflow = false;
std::cout << “[New Scene Loaded]: ” << currentScene << “\n”;
std::cout << “姊姊獨自坐在禮堂的窗邊…\n”;
}

int getCycleCount() const { return cycleCount; }
};

int main() {
std::cout << “【2025春】告白遞迴棧溢出\n”;
MemoryStack timeline;
timeline.pushScene(“2025年3月17日，似乎，是一場夢。”);

// 第一個循環
std::cout << “\n=== 第一循環開始 ===\n”;
timeline.recursiveLoop(0, 3, 1);

// 第二個循環
std::cout << “\n=== 第二循環開始 ===\n”;
timeline.recursiveLoop(0, 3, 2);

std::cout << “\n[Total Cycles]: ” << timeline.getCycleCount() << “\n”;
return 0;
}

2025年3月17日
熟悉的天花板。
似乎，是一场梦。
毕业的倦怠如同无穷无尽的函数和程式码压迫着神经。但是，头脑却异常清明。毕业典礼刚刚结束，喧嚣的礼堂已经散场，只剩下礼堂里为毕业典礼而准备的装饰这些临时变量。所有的同学似乎都已离开到充盈着春日气息的外面去。我独自坐在靠窗的位子上，呆呆地望着手上被阳光染成金黄色的丸筒，接着再次启封倒出毕业证书。
「全部课程修毕。此证。」
我心里知晓我留下来并不是为了看这个的。
但是，为什么要留下来也不知道。
正当我准备起身离开这里去和同学们道别时，礼堂的门突然被推开。进来的是妹妹。
「…啊，妹妹。什么事？」
「姊姊！我找了妳好久！」
「典礼结束了…我只是想一个人在这里待一会。找我做什么？」
妹妹快步走到我的面前，毫不犹豫地将手上的东西塞进我的掌心。那不是实体，而是一串闪烁不定，半透明地悬在空气中的数据流。我低头凝视，其上浮动着一串扭曲的金钥识别码——
0x7aF9b3eC2d8f91c4aB6eD5f8e39cC4d1F92eA741 : 483920174
墨迹有些晕开，像被泪水浸过似的。我问她：
「这是什么？」
「这是我写的啊！现在最流行的『实体』NFT藏品！毕业礼物！」妹妹双手叉腰，语气中不乏自信，「我还以为姊姊毕业典礼完就会灰溜溜回家呢！幸好我有来礼堂看看！」
春日的微风从窗外溜进，撩动她的裙摆。制服贴合身体时隐约透出的柔软的质感，随着她轻盈的呼吸微微起伏。妹妹胸口自然隆起的弧度随着没扣上的第一枚纽扣而敞开的衣领若隐若现——妹妹的蝴蝶结不见了。我的手指感受着妹妹递过来的资料流的触感，以此寻求某种真实。
「姊姊，毕业了感觉怎么样？」
「有种…不，我好像也不太知道啊。为什么我会在这里乖乖坐着呢？也许是在等人吧。」
我并非不知道自己是什么感觉。毕业的倦怠感很重。上学时恍恍惚惚，一到毕业就觉得十分迷茫，恍惚间就突然变成大人。明明自己连爱都没做过也可以称之为大人吗。
「那么，姊姊应该就是在等我吧。因为心里默认了要和亲妹妹见面。」
「嗯。」我对她浅浅一笑，「那就应该是这样的。那么，谢谢妳的毕业礼物。姊姊可算是毕业可以出去挣钱了呢，第一个月的工资也会给妳买礼物的。」
妹妹拉过一个椅子坐到我的对面。礼堂外传来欢笑的声音，无数同龄人正忙着告别，准备奔向各自崭新的未来。如果抛开自己的那些迷茫平心而论，看着礼堂内尽心准备的彩带，今天还真是个不错的日子。明明学校不种樱花，我却分明看到了无数樱花瓣在风中飘散。妹妹宠溺地看着我说：
「如果能一直和姊姊呆在这里就好了呢。哪也不去。会有这样可以一直运行的程式吗？」
「当然是有的啊。比如说——

#include <iostream>
#include <thread>
#include <vector>
#include <random>
#include <mutex>
#include <chrono>

class Galaxy {
private:
int stars;
std::string name;
public:
Galaxy(std::string n, int s) : name(n), stars(s) {}
void evolve() {
stars += (rand() % 10) – 5; // 隨機增減星星數量
if (stars <= 0) stars = 1; // 保證至少有1顆星
}
void report() const {
std::cout << “星系 ” << name << ” 目前有 ” << stars << ” 顆星\n”;
}
};

class UniverseSimulator {
private:
std::vector<Galaxy> galaxies;
std::mutex mtx;
bool running;
std::random_device rd;
std::mt19937 gen;

public:
UniverseSimulator() : running(true), gen(rd()) {
// 初始化示例星系
galaxies.emplace_back(“銀河系”, 100);
galaxies.emplace_back(“仙女座”, 150);
galaxies.emplace_back(“三角座”, 80);
}

void spawnGalaxies() {
while (running) {
std::uniform_int_distribution<> dis(50, 200);
int starCount = dis(gen);
std::string newName = “未知星系_” + std::to_string(galaxies.size() + 1);
{
std::lock_guard<std::mutex> lock(mtx);
galaxies.emplace_back(newName, starCount);
std::cout << “生成新星系: ” << newName << ” (” << starCount << ” 顆星)\n”;
}
std::this_thread::sleep_for(std::chrono::seconds(2)); // 每2秒生成一個
}
}

void evolveGalaxies() {
while (running) {
{
std::lock_guard<std::mutex> lock(mtx);
for (auto& galaxy : galaxies) {
galaxy.evolve();
galaxy.report();
}
std::cout << “宇宙目前有 ” << galaxies.size() << ” 個星系\n”;
}
std::this_thread::sleep_for(std::chrono::seconds(1)); // 每秒演化一次
}
}

void runForever() {
std::thread spawnThread(&UniverseSimulator::spawnGalaxies, this);
std::thread evolveThread(&UniverseSimulator::evolveGalaxies, this);

spawnThread.detach(); // 分離執行緒使其獨立運行
evolveThread.detach();

// 主執行緒保持運行
while (true) {
std::this_thread::sleep_for(std::chrono::seconds(10));
std::cout << “[宇宙模擬器]: 持續運行中…\n”;
}
}
};

int main() {
std::cout << “啟動宇宙模擬器…\n”;
UniverseSimulator simulator;
simulator.runForever();
return 0; // 永遠不會到達的地方
}

这个经典的宇宙模拟器能一直运行是因为利用了多个并行的无限循环。只要硬体资源未耗尽，这些循环没有终止条件，程式就会无休止地执行下去。」
「宇宙吗…的确，主执行绪通过 while(true)持续监控状态，两条分离的子执行绪分别通过spawnGalaxies和evolveGalaxies在独立无穷的while(running)循环中不断生成新星系和演化现有星系，而且还专门加了互斥锁…姊姊，妳偶尔也很浪漫呢。」
其实我不明白我在说些什么，只是话语自然而然地从嘴里说出来，如预载的输出流自然从唇间溢出，彷彿早已在记忆体中待命。
「所以，我不想向姊姊告白了。」
「诶！？？」我猛地一怔，「怎么突然扯到这个！？」
「如果我不告白的话，到底会怎样呢？」歪头等待未定义的返回值的妹妹眼底藏着一抹试探。「如果我不告白，这个循环会不会停下来？姊姊，妳觉得呢？」她凝视着我，眼眸深处闪闪发光，「姊姊永远不会毕业永远陪在我身边，实在很有趣呀。如果没有告白，这个程式还会继续跑吗？还是会卡进bug里？」
我不知道。手中的丸筒滑落，滚到桌角里。但我很快就回应道：

「我不清楚妳为什么要向我告白。」

「因为我喜欢姊姊所以准备告白。」

「嗯…如果告白会怎样？」

我比自己想象中还要冷静。意料之中，Lorenz的蝴蝶似乎振翅于此瞬，早已三番五次听过类似的发言，并且并不是多么遥远的事。

「告白。程式就会重启。」

「缸中之脑？」

「我不知道诶。姊姊愿意相信吗？我说的话。」

「既然是妹妹这么说我就100%相信。」

「好诶——」妹妹忽地扑过来双臂环住我，我感受着这份来之不易的温暖和柔软涌入器官。如果触及妹妹湿润的眼眸和泛红的脸颊，连这份真都无法信赖，我唯有被迫触摸无穷无尽的冰冷，这个世界自然也无存在的意义。自是正论。世界并非以无意义而存在。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <queue>
#include <random>
#include <chrono>
#include <memory>
#include <cmath>

enum class ExistentialState { STABLE, FLUX, VOID, PARADOX }; // 存在狀態枚舉

class MemoryFragment {
public:
std::string essence;
double resonance; // 記憶共振值
MemoryFragment(std::string e, double r) : essence(e), resonance(r) {}
};

class ChaosThread {
private:
std::string identity;
ExistentialState state;
double entropy; //熵值
std::vector<std::shared_ptr<MemoryFragment>> reflections; // 自指性記憶
std::mutex& mtx;
std::condition_variable& cv;
std::queue<std::string> paradoxEvents; // 悖論事件隊列
std::mt19937 gen;
double chaosFactor; // Logistic映射因子

double logisticMap(double x) { // 映射函數
return 4.0 * x * (1.0 – x); // Logistic公式
}

public:
ChaosThread(std::string id, std::mutex& m, std::condition_variable& c)
: identity(id), state(ExistentialState::STABLE), entropy(0.5), mtx(m), cv(c), gen(std::random_device{}()), chaosFactor(0.5) {}

void updateExistence() {
std::uniform_real_distribution<> dis(-0.1, 0.1);
chaosFactor = logisticMap(chaosFactor + dis(gen)); // 非線性演化
entropy = std::max(0.0, std::min(1.0, entropy + chaosFactor * dis(gen)));
if (entropy > 0.8) state = ExistentialState::PARADOX;
else if (entropy > 0.5) state = ExistentialState::FLUX;
else if (entropy > 0.2) state = ExistentialState::STABLE;
else state = ExistentialState::VOID;
}

void reflectSelf(const std::string& essence, double resonance) {
std::lock_guard<std::mutex> lock(mtx);
reflections.push_back(std::make_shared<MemoryFragment>(essence, resonance));
std::cout << identity << ” 反射記憶: ” << essence << ” (共振: ” << resonance << “)\n”;
}

void processParadox() {
std::uniform_int_distribution<> dis(0, 4);
std::string events[] = {“自我消解”, “他者凝視”, “時間斷裂”, “存在重疊”};
if (dis(gen) == 0 && !paradoxEvents.empty()) {
std::lock_guard<std::mutex> lock(mtx);
std::cout << identity << ” 觸發悖論: ” << paradoxEvents.front() << “\n”;
entropy += 0.1; // 悖論增熵
paradoxEvents.pop();
} else {
paradoxEvents.push(events[dis(gen)]);
}
}

void resonate() {
while (true) {
updateExistence();
processParadox();
{
std::lock_guard<std::mutex> lock(mtx);
std::cout << identity << ” 狀態: ” << static_cast<int>(state)
<< “, 熵值: ” << entropy << “,映射因子: ” << chaosFactor << “\n”;
for (auto& ref : reflections) {
ref->resonance = logisticMap(ref->resonance); // 記憶共振演化
if (ref->resonance < 0.01) ref.reset(); // 衰減至無
}
reflections.erase(
std::remove_if(reflections.begin(), reflections.end(),
[](const std::shared_ptr<MemoryFragment>& r) { return !r; }),
reflections.end());
}
std::unique_lock<std::mutex> lock(mtx);
cv.notify_one(); // 同步對方執行緒
std::this_thread::sleep_for(std::chrono::milliseconds(700));
}
}
};

class ChaosCoexistSimulator {
private:
std::mutex mtx;
std::condition_variable cv;
bool running;
ChaosThread self1;
ChaosThread self2;
double globalEntropy; // 全局熵

public:
ChaosCoexistSimulator()
: running(true), self1(“姊姊”, mtx, cv), self2(“妹妹”, mtx, cv), globalEntropy(0.5) {
self1.reflectSelf(“妹妹的擁抱”, 0.6);
self2.reflectSelf(“姊姊的凝視”, 0.6);
}

void synchronizeChaos() {
while (running) {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock); // 等待共振
globalEntropy = logisticMap(globalEntropy); // 全局熵演化
std::cout << “[模擬器]: 姊妹存在共振，全局熵: ” << globalEntropy << “\n”;
std::this_thread::sleep_for(std::chrono::seconds(3));
}
}

void evolveExistence() {
std::cout << “[模式轉換]: 從告白循環切換至共存模擬\n”;
std::thread thread1(&ChaosThread::resonate, &self1);
std::thread thread2(&ChaosThread::resonate, &self2);
std::thread syncThread(&ChaosCoexistSimulator::synchronizeChaos, this);
thread1.detach();
thread2.detach();
syncThread.detach();

while (running) {
std::this_thread::sleep_for(std::chrono::seconds(5));
std::cout << “[模擬器]: 存在於宇宙中無限演化…\n”;
}
}
};

int main() {
std::cout << “啟動姊妹共存模擬器…\n”;
ChaosCoexistSimulator simulator;
simulator.evolveExistence();
return 0; // 永恆未達之終
}

「原来如此…」妹妹喃喃道，「如果打破告白的触发条件，堆叠就不会溢出临界值。那么，告别了告白的单向循环，这算什么？方才的宇宙循环plus？姊姊为我构建的并行运算？」

「只不过蜕变成另一种非线性动力学上的随机循环而已。不过，比宇宙的经典演化还要复杂混沌许多。」

她的温度渗入我的内核，妹妹的思想是一条独立的执行绪与我的执行绪共振。手中那串NFT的资料流崩散，取而代之的是掌心的热度。

我们抱在一起好久时间在礼堂的寂静中凝滞。窗外的天空染上暖黄，春日的余晖如缓慢渲染的虚像，将我们的影子交叠于木椅之间。我不愿放手。

我不愿放手。存在状态随着熵值跳跃，记忆如Logistic映射般演化，自不待言深感自指性的悬浮感包围四周，声音如同被静音的音轨逐渐隐去。并非重启和崩溃的某种支线的预期。试图抓住情感的蛛丝马迹思绪已然变作坏掉的指针指向虚无。春风拂面。笑声远逝。沉默凝视。泪光闪现，却无崩溃之兆。

缸中之脑。

Fin.

不存在的结局

欸，是不是有哪里不太对啊。

「欸…等等，告白！？妳刚刚是不是有说喜欢我？乱伦什么的怎么可能啊！我还没有准备好！」

「响应好慢！姊姊搭载的是什么上古单核CPU吗？心跳怎么又溢出了！？来不及啦！妳的妹妹又要被重新解包啦笨蛋姊姊！等我回来！」

void detectConfession() { // 告白檢測
std::lock_guard<std::mutex> lock(mtx);
if (identity == “姊姊” && !confessionDetected) {
std::cout << “[告白確認]: 姊姊反應過來，重啟告白循環！\n”;
confessionDetected = true;

2025年3月17日

似乎，是一场梦。

毕业好累啊。

……

Fin.