计算机组成原理试卷一：从歪扭的指令到混乱的堆栈 第一章：指令集里的鬼魅 在汇编语言的噩梦降临之前，CPU 实际上是个挺闲的东西，就是把一堆看似凌乱无章的机器码给凑合起来。
这哥们儿可没耐心，遇到未定义的跳过指令，直接就去死。
比方说，你写一句 `MOV R0, 0`，它自己知道 R0 是个寄存器，也知道 0 是个常量，但最关键的 `MOV` 指令里，来源和目标都缺了。
这就像你让一个厨师把 0 号食材放进 R0，结局厨师手里连个空盘子都没有，只能去问厨师长：“把那个 0 号食材拿过来，再给个空盘子。”结局厨师长拿着不明来源的 0 号食材，又去问厨师长：“这个盘子是哪来的？” 实际上，现代编译器已经把这个“空盘子”的活儿干到了极致。当机器码里没有直接提到 R0 时，编译器会自动派个寄存器 X0 来干这个活，然后告诉你：“嘿，R0 占地方，下次再用的时候把它腾出来。”这种隐式定义，让程序员认定心里踏实。再比如数据移动，`MOV R0, 1`, 这条指令看起来像是在说“把 1 放进 R0"，但真正执行的逻辑往往是：“把寄存器 R0 里的内容，按位拷贝一份，然后塞进内存地址 1 里。” 要是指令集不够用，CPU 就得把寄存器当仓库用，把内存当仓库用，最终肉掌都堆不上去。
这就好比你家里没衣柜，你非要把衣服塞进床底，结局衣服陷进床垫里泡坏了，你也找不到衣服。
这时候，编译器就得想办法，把寄存器用作临时存区，要么干脆用内存来当寄存器，别看内存读写慢了点，但总还得用。 第二章：从十进制的泥潭到二进制的迷宫 有时候，我们需求把十进制数转成二进制数。
比如 5 是多少？用十进制的表达法说，就是 1 加 1 加 1，加起来正好 3。但在二进制的迷宫里，5 这个数字显得那么格格不入，它像是一个穿着奇装异服的新手，根本混不进现有的队伍。 要解开这个谜题，得看看计算机到底如何记数。十进制靠的是逢十进一，也就是 5+1=6。但二进制，计算机的亲戚，只能靠逢二进一。
这意味着，5 这个数，在二进制看来，得拆成 1 加 1 加 1，这在十进制的写法里是 101。
如何算？从左往右数，第一位是 1，第二位是 0，第三位是 1。
第一位代表 8 权，第二位代表 4 权，第三位代表 2 权。算一下：1 乘以 8 等于 8，0 乘以 4 等于 0，1 乘以 2 等于 2。加起来就是 8+0+2=10。
哎呀，算错了。 什么的，我的脑子是不是有点糊涂？还是计算器坏了？不管了，直接换个算法。从右往左数，第一位是 1，乘以 2 得 2。
第二位是 0，乘以 2 得 0。
第三位是 1，乘以 2 得 4。加起来是 2+0+4=6。还是不对。
天哪，二进制转十进制的逻辑是不是我记反了？ 算了，别纠结了。二进制转十进制，实际上就是把每一位的权值乘起来再相加。1 乘以 2 的 0 次方是 1，1 乘以 2 的 1 次方是 2，1 乘以 2 的 2 次方是 4。加起来 1+2+4=7。
如何还是不对？
难道 5 的二进制确实是 101 吗？1 是 8，0 是 4，1 是 2。8+4+2=14。
天哪，我是不是把二进制权值的顺序搞反了？从右往左，第一位是 2 的 0 次方，第二位是 2 的 1 次方，第三位是 2 的 2 次方。
故此 101 应当是 14 + 02 + 11 = 5。
对，就是这样了。 有时候，计算器会显得有点笨。你输入 5，它回的是 101。
然后你输入 101，它又回 5。
这就像你在玩真心话大冒险，问对方一个难题，对方答对了，你就拿到真心话。但要是是反着来，你问它“多少是 5"，它却回答了“7"。
这种令人啼笑皆非的对话，往往形成在把十进制和二进制搞混的时候。 第三章：堆栈里的哲学与逻辑死胡同 程序里最让人头疼的东西，莫过于数据堆栈。它就像你家门口的一个储物柜，专门用来放临时捡到的东西。
每次你要出门，就把想要的东西扔进储物柜；每次你出门前，就先把东西取出来。 假设你要去取一个东西，你把手伸进储物柜，摸到那个东西扔出来。
这就是取栈顶元素。
这时候，栈顶元素又往回挪一格，变成了新的栈顶。
要是栈空了如何办？比如，你刚刚把东西扔进去，结局门没关严，东西掉地上了。
这时候你得赶紧去捡，不然下次你伸手进去，嘿，没东西拿，还得再扔进去。 再比如，你要扔东西。你把手伸进去，往底端一放。
这时候，栈顶元素又往上一格，变成了新的栈顶。
要是栈顶元素本来没有东西，目前你往底端一放，那底端是不是就变空了？不对，是底端少了一个。
这就好比你在一个空桶里倒水，水倒进空桶里，水面上升。
这时候，要是你又往底端一放水，那桶底是不是就空了？不对，是桶底少了一个。 什么的，我是不是说反了？让我重新理一下。桶底是原来的底端，桶口是原来的底端。当你往桶里倒水，水面升高。
要是桶里本来就没有水，目前你往桶底一倒，那原来的桶底是不是就空了？不对，是原来的桶底少了一个。 好吧，别纠结了。栈顶元素原来是桶口，目前桶口是原来的桶底。当你往桶里倒水，水面升高。
要是桶里本来就没有水，目前你往桶底一倒，那原来的桶底是不是就空了？不对，是原来的桶底少了一个。 第四章：例外处理的无奈摊派 有时候，程序里会突发奇想，非要做点没想到的事。
比方说，你让 CPU 去把某个地址里的数据，去翻个身，要么去转个圈。
这时候，CPU 就得照这个指令要求去执行。 要是这个地址里是 0，CPU 就去把 0 给转个身。
要是转个身之后，还是 0。
这时候，CPU 就得把 0 这个数据，又转回原来的地址。
这就像你让一个人去翻个身，结局他翻回来还是原样，这时候你得把这个人给转回来。 要是这个地址里是 1，CPU 就去把 1 给转个身。转个身之后，变成了 0。
这时候，CPU 就得把 1 这个数据，又转回原来的地址。
这就像你让一个人去翻个身，结局他翻回来变成了 0，这时候你得把这个 0 给转回原来的地址。 有时候，CPU 还会挺绅士，主动去帮忙。
比方说，你让 CPU 去把某个地址里的数据，给转个身。
这时候，CPU 发现转个身之后，还是原样。
这时候，CPU 就主动去把这个人给转回来。
这就像你让一个人去翻个身，结局他翻回来还是原样，这时候 CPU 就主动去把这个 0 给转回原来的地址。 第五章：调试的独门绝活 调试这个活儿，实际上挺难的。
你想象一下，你让 CPU 去做个无底洞，结局它确实挖到了。
这时候，你就不得不从头启动重新做。 比如，你写个程序，让 CPU 把某个地址里的数据翻个身。结局你翻过之后，还是原样。
这时候，你就得从头启动重新写。
这就像你写个作业，写了一页，结局检查结局却是“完美”。
这时候你得重新写。 再比如，你让 CPU 把某个地址里的数据转个身。结局转完之后，还是原样。
这时候，你就得从头启动重新写。
这就像你让一个人去翻个身，结局他翻回来还是原样，这时候你得把这个 0 给转回原来的地址。 有时候，CPU 还会挺热情，主动去帮忙。
比方说，你让 CPU 去把某个地址里的数据，给转个身。
这时候，CPU 发现转个身之后，还是原样。
这时候，CPU 就主动去把这个人给转回来。
这就像你让一个人去翻个身，结局他翻回来还是原样，这时候 CPU 就主动去把这个 0 给转回原来的地址。 有时候，CPU 就连会挺贴心，主动帮忙。
比方说，你让 CPU 去把某个地址里的数据，给转个身。
这时候，CPU 发现转个身之后，还是原样。
这时候，CPU 就主动去把这个人给转回来。
这就像你让一个人去翻个身，结局他翻回来还是原样，这时候 CPU 就主动去把这个 0 给转回原来的地址。 有时候，CPU 就连会挺贴心，主动帮忙。
比方说，你让 CPU 去把某个地址里的数据，给转个身。
这时候，CPU 发现转个身之后，还是原样。
这时候，CPU 就主动去把这个人给转回来。
这就像你让一个人去翻个身，结局他翻回来还是原样，这时候 CPU 就主动去把这个 0 给转回原来的地址。 第六章：寄存器冲突的尴尬时刻 有时候，程序里会出现一种尴尬。你让 CPU 把数据从 A 放进 B。结局，B 本来是个寄存器，目前又变成内存了。
这时候，你让 CPU 把数据从 A 放进 C。结局，C 本来是个内存，目前又变成寄存器了。
这时候，你让 CPU 把数据从 A 放进 D。结局，D 本来是个寄存器，目前又变成内存了。 这时候，CPU 就不得不尴尬了。它得把数据从 A 放进 B，结局 B 变成了内存。
这时候，它得把数据从 A 放进 C，结局 C 变成了寄存器。
这时候，它得把数据从 A 放进 D，结局 D 变成了内存。 有时候，CPU 会显得挺尴尬。
比方说，你让 CPU 把数据从 A 放进 B。结局，B 变成了内存。
这时候，它得把数据从 A 放进 C，结局 C 变成了寄存器。
这时候，它得把数据从 A 放进 D，结局 D 变成了内存。 有时候，CPU 会显得挺尴尬。
比方说，你让 CPU 把数据从 A 放进 B。结局，B 变成了内存。
这时候，它得把数据从 A 放进 C，结局 C 变成了寄存器。
这时候，它得把数据从 A 放进 D，结局 D 变成了内存。 第七章：快速排序的奇怪怪 快速排序这个算法，有时候会显得特别怪。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，CPU 会显得挺怪。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，CPU 会显得挺怪。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 第八章：溢出与下溢的生死线 有时候，程序里的数据，可能会不小心溢出。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里的数据，可能会不小心下溢。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 第九章：栈操作中的深层逻辑 有时候，程序里的数据，可能会不小心下溢。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里的数据，可能会不小心下溢。
比方说，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 第十章：异常处理的终极演练 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 再比如，你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原样。
这时候，CPU 就得把这个人给转回来。 有时候，程序里会出现一种情况。你让 CPU 把某个地址里的数据，给转个身。
这时候，转完之后，发现还是原
