6.3 非局部名字的访问 本节介绍 无过程嵌套的静态作用域（C语言） 有过程嵌套的静态作用域（Pascal语言） 动态作用域（Lisp语言）

6.3 非局部名字的访问 6.3.1 无过程嵌套的静态作用域 过程体中的非局部引用可以直接使用静态确定的地址（非局部数据此时就是全局数据） 局部变量在栈顶的活动记录中，可以通过base_sp指针来访问 无须深入栈中取数据，无须访问链 过程可以作为参数来传递，也可以作为结果来返回

6.3 非局部名字的访问 6.3.2 有过程嵌套的静态作用域 sort readarray exchange quicksort partition

6.3 非局部名字的访问 6.3.2 有过程嵌套的静态作用域 过程嵌套深度 sort 1 readarray 2 exchange 2 quicksort 2 partition 3 变量的嵌套深度：它的声明所在过程的嵌套 深度作为该名字的嵌套深度

6.3 非局部名字的访问 访问链 用来寻找非局部 名字的存储单元 e (1, 3) i, j p (1, 3) q (1, 3) k, v 6.3 非局部名字的访问 访问链 用来寻找非局部 名字的存储单元 s a, x q (1, 9) k, v 访问链 q (1, 3) p (1, 3) i, j e (1, 3)

6.3 非局部名字的访问 访问非局部名字的存储单元 假定过程p的嵌套深度为np，它引用嵌套深度为na 的变量a，na  np，如何访问a的存储单元 sort 1 readarray 2 exchange 2 quicksort 2 partition 3 s a, x q (1, 3) k, v 访问链 q (1, 9)

6.3 非局部名字的访问 访问非局部名字的存储单元 假定过程p的嵌套深度为np，它引用嵌套深度为na 的变量a，na  np，如何访问a的存储单元 从栈顶的活动记录开始，追踪访问链np  na次 到达a的声明所在过程的活动记录 访问链的追踪用间接操作就可完成 sort 1 readarray 2 exchange 2 quicksort 2 partition 3 s a, x q (1, 3) k, v 访问链 q (1, 9)

6.3 非局部名字的访问 访问非局部名字的存储单元 sort readarray exchange quicksort partition 6.3 非局部名字的访问 访问非局部名字的存储单元 e (1, 3) 访问链 s a, x q (1, 3) k, v q (1, 9) p (1, 3) i, j sort readarray exchange quicksort partition s a, x q (1, 3) k, v 访问链 q (1, 9) p (1, 3) i, j s a, x q (1, 3) k, v 访问链 q (1, 9) s a, x q (1, 9) k, v 访问链

6.3 非局部名字的访问 过程p对变量a访问时，a的地址由下面的二元组表示： （np  na，a在活动记录中的偏移）

6.3 非局部名字的访问 建立访问链 (1) np < nx的情况 sort 1 假定嵌套深度为np的过程p调用嵌套深度为nx的过程x (1) np < nx的情况 sort 1 readarray 2 exchange 2 quicksort 2 partition 3 这时x肯定就声明在p中，且nx=np+1，由过程p建立x的活动记录

6.3 非局部名字的访问 建立访问链 (1) np < nx的情况 假定嵌套深度为np的过程p调用嵌套深度为nx的过程x 被调用过程的访问链必须指向调用过程的活动记录的访问链

6.3 非局部名字的访问 访问非局部名字的存储单元 sort readarray exchange quicksort partition 6.3 非局部名字的访问 访问非局部名字的存储单元 s a, x q (1, 9) k, v 访问链 q (1, 3) p (1, 3) i, j e (1, 3) sort readarray exchange quicksort partition

6.3 非局部名字的访问 sort 1 建立访问链 (2) np  nx的情况 假定嵌套深度为np的过程p调用嵌套深度为nx的过程x (2) np  nx的情况 sort 1 readarray 2 exchange 2 quicksort 2 partition 3 这时p和x的嵌套深度分别为1，2，…，nx 1的外围过程肯定相同

6.3 非局部名字的访问 建立访问链 (2) np  nx的情况 假定嵌套深度为np的过程p调用嵌套深度为nx的过程x 追踪访问链np  nx + 1次，到达了静态包围x和p的且离它们最近的那个过程的最新活动记录 所到达的活动记录就是x的活动记录中的访问链应该指向的那个活动记录

6.3 非局部名字的访问 访问非局部名字的存储单元 sort readarray exchange quicksort partition 6.3 非局部名字的访问 访问非局部名字的存储单元 s a, x q (1, 9) k, v 访问链 q (1, 3) p (1, 3) i, j e (1, 3) sort readarray exchange quicksort partition

6.3 非局部名字的访问 函数f作为参数传递时，怎样在f被激活时建立它的访问链 program param(input, output);（过程作为参数） procedure b(function h(n: integer): integer); begin writeln(h(2)) end {b}; procedure c; var m: integer; function f(n: integer): integer; begin f := m+n end {f}; begin m := 0; b(f) end {c}; begin c end. 函数f作为参数传递时，怎样在f被激活时建立它的访问链

6.3 非局部名字的访问 从b的访问链难以建立f的访问链 program param(input, output);（过程作为参数） procedure b(function h(… begin writeln(h(2)) end ; procedure c; var m: integer; function f(n: integer)… begin f := m+n end {f}; begin m := 0; b(f) end {c}; begin c end. 访 问 链 param c m b <f > 从b的访问链难以建立f的访问链

6.3 非局部名字的访问 program param(input, output);（过程作为参数） procedure b(function h(… begin writeln(h(2)) end ; procedure c; var m: integer; function f(n: integer)… begin f := m+n end {f}; begin m := 0; b(f) end {c}; begin c end. 访 问 链 param c m b <f, > f作为参数传递时，它的起始地址连同它的访问链一起传递 18

6.3 非局部名字的访问 program param(input, output);（过程作为参数） procedure b(function h(… begin writeln(h(2)) end ; procedure c; var m: integer; function f(n: integer)… begin f := m+n end {f}; begin m := 0; b(f) end {c}; begin c end. 访 问 链 param c m b <f, > f b调用f时，用传递过来的访问链来建立f的访问链 19

6.3 非局部名字的访问 program ret (input, output);（过程作为返回值） var f: function (integer): integer; function a: function (integer): integer; var m: integer; function addm (n: integer): integer; begin return m+n end; begin m:= 0; return addm end; procedure b (g: function (integer): integer); begin writeln (g(2)) end; begin f := a; b(f) end. a ret b addm

6.3 非局部名字的访问 执行addm时，a的活动记录已不存在，取不到m的值 program ret (input, output);（过程作为返回值） var f: function (integer): integer; function a: function (integer): integer; var m: integer; function addm (n: integer): integer; begin return m+n end; begin m:= 0; return addm end; procedure b (g: function (integer): integer); begin writeln (g(2)) end; begin f := a; b(f) end. a ret b addm 执行addm时，a的活动记录已不存在，取不到m的值 21

6.3 非局部名字的访问 C语言的函数声明不能嵌套，函数不论在什么情况下激活，要访问的数据分成两种情况 非静态局部变量（包括形式参数），它们分配在活动记录栈顶的那个活动记录中 外部变量（包括定义在其它源文件之中的外部变量）和静态的局部变量，它们都分配在静态数据区 因此C语言允许函数（的指针）作为返回值

6.3 非局部名字的访问 6.3.3 动态作用域 被调用过程的非局部名字a和它在调用过程中引用的是同样的存储单元 基于运行时的调用关系 而不是基于静态作用域来确定 新的绑定仅为被调用过程的局部名字建立，这些名字在被调用过程的活动记录中占用存储单元 这一点与静态作用域没有区别

6.3 非局部名字的访问 program dynamic(input, output); dynamic var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small

6.3 非局部名字的访问 program dynamic(input, output); dynamic var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin 静态作用域 r := 0.25; 0.250 0.250 show; small; writeln; 0.250 0.250 show; small; writeln end. dynamic show small

6.3 非局部名字的访问 program dynamic(input, output); dynamic var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin 动态作用域 r := 0.25; 0.250 0.125 show; small; writeln; 0.250 0.125 show; small; writeln end. dynamic show small

6.3 非局部名字的访问 实现动态作用域的方法 深访问 浅访问 用控制链搜索运行栈，寻找包含该非局部名字的第一个活动记录 为每个名字在静态分配的存储空间中保存它的当前值 当过程p的新活动出现时，p的局部名字n使用在静态数据区分配给n的存储单元。n的先前值保存在p的活动记录中，当p的活动结束时再恢复

6.3 非局部名字的访问 program dynamic(input, output); var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin (绿色表示已执行部分) r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small ? r 静态区 使用值的地方 栈区 暂存值的地方 dynamic

6.3 非局部名字的访问 program dynamic(input, output); var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin (绿色表示已执行部分) r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small 0.25 r dynamic ? 静态区 使用值的地方 栈区 暂存值的地方

6.3 非局部名字的访问 program dynamic(input, output); var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin (绿色表示已执行部分) r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small 0.25 r dynamic ? show 静态区 使用值的地方 栈区 暂存值的地方

6.3 非局部名字的访问 program dynamic(input, output); var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin (绿色表示已执行部分) r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small 0.25 r dynamic ? small 静态区 使用值的地方 栈区 暂存值的地方

6.3 非局部名字的访问 program dynamic(input, output); var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin (绿色表示已执行部分) r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small 0.125 r dynamic ? small 0.25 静态区 使用值的地方 栈区 暂存值的地方

6.3 非局部名字的访问 program dynamic(input, output); var r: real; procedure show; begin write(r: 5: 3) end; procedure small; begin r := 0.125; show end; begin (绿色表示已执行部分) r := 0.25; show; small; writeln; show; small; writeln end. dynamic show small 0.25 r dynamic ? 静态区 使用值的地方 栈区 暂存值的地方

6.4 参 数 传 递 6.4.1 值调用 实参的右值传给被调用过程 值调用可以如下实现 把形参当作所在过程的局部名看待，形参的存储单元在该过程的活动记录中 调用过程计算实参，并把其右值放入被调用过程形参的存储单元中

6.4 参 数 传 递 6.4.2 引用调用 实参的左值传给被调用过程 引用调用可以如下实现： 把形参当作所在过程的局部名看待，形参的存储单元在该过程的活动记录中 调用过程计算实参，把实参的左值放入被调用过程形参的存储单元 在被调用过程的目标代码中，任何对形参的引用都是通过传给该过程的指针来间接引用实参

6.4 参 数 传 递 6.4.3 换名调用 从概念上说，每次调用时，用实参表达式对 形参进行正文替换，然后再执行 procedure swap(var x, y: integer); var temp: integer; begin temp := x; x := y; y := temp end

6.4 参 数 传 递 6.4.3 换名调用 从概念上说，每次调用时，用实参表达式对 形参进行正文替换，然后再执行 procedure swap(var x, y: integer); var temp: integer; 例如： 调用swap(i, a[i]) begin temp := x; x := y; y := temp end

6.4 参 数 传 递 6.4.3 换名调用 从概念上说，每次调用时，用实参表达式对 形参进行正文替换，然后再执行 procedure swap(var x, y: integer); var temp: integer; 例如： 调用swap(i, a[i]) begin 替换结果： temp := i; temp := x; i := a[i]; x := y; a[i] := temp y := temp end

6.4 参 数 传 递 6.4.3 换名调用 从概念上说，每次调用时，用实参表达式对 形参进行正文替换，然后再执行 procedure swap(var x, y: integer); var temp: integer; 例如： 调用swap(i, a[i]) begin 替换结果： temp := i; temp := x; i := a[i]; x := y; a[i] := temp y := temp 交换两个数据的程序 end 并非总是正确

6.5 堆 管 理 堆式分配 堆用来存放生存期不确定的数据 堆空间的回收有两种不同方式 6.5 堆 管 理 堆式分配 堆用来存放生存期不确定的数据 C++和Java允许程序员用new创建对象，它们的生存期没有被约束在创建它们的过程活动的生成期之内 实现内存回收是内存管理器的责任 堆空间的回收有两种不同方式 程序显式释放空间：free（C）或delete（C++） 垃圾收集器自动收集（Java）。11.3节介绍垃圾收集算法，本课程不做介绍

6.5 堆 管 理 6.5.1 内存管理器 内存管理器把握的基本信息是堆中空闲空间 内存管理器应具有下列性质 分配函数 回收函数 6.5 堆 管 理 6.5.1 内存管理器 内存管理器把握的基本信息是堆中空闲空间 分配函数 回收函数 内存管理器应具有下列性质 空间有效性：极小化程序需要的堆空间总量 程序有效性：较好地利用内存子系统，使得程序能运行得快一些 低开销：分配和回收操作所花时间在整个程序执行时间中的比例尽量小

6.5 堆 管 理 6.5.2 计算机内存分层 虚拟内存(磁盘) 物理内存 2级缓存 1级缓存 寄存器(处理器) 典型大小 6.5 堆 管 理 6.5.2 计算机内存分层 虚拟内存(磁盘) 物理内存 2级缓存 1级缓存 寄存器(处理器) 典型大小 > 2千兆字节 256兆2千兆字节 128千4兆字节 1664千字节 32字 典型访问时间 315微秒 100150纳秒 4060纳秒 510纳秒 1纳秒

6.5 堆 管 理 6.5.2 计算机内存分层 现代计算机都设计成程序员不用关心内存子系统的细节就可以写出正确的程序 6.5 堆 管 理 6.5.2 计算机内存分层 现代计算机都设计成程序员不用关心内存子系统的细节就可以写出正确的程序 程序的效率不仅取决于被执行的指令数，还取决于执行每条指令需要多长时间 执行一条指令的时间区别非常可观 差异源于硬件技术的基本局限：构造不了大容量的高速存储器 数据以块（缓存行、页）为单位在相邻层次之间进行传送 数据密集型程序可从恰当利用内存子系统中获益

6.5 堆 管 理 6.5.3 程序局部性 大多数程序的大部分时间在执行一小部分代码，并且仅涉及一小部分数据 时间局部性 空间局部性 6.5 堆 管 理 6.5.3 程序局部性 大多数程序的大部分时间在执行一小部分代码，并且仅涉及一小部分数据 时间局部性 程序访问的内存单元在很短的时间内可能再次被程序访问 空间局部性 毗邻被访问单元的内存单元在很短的时间内可能被访问

6.5 堆 管 理 6.5.3 程序局部性 即使知道哪些指令会被频繁执行，最快的缓存也可能没有大到足以把它们同时放在其中，因此必须动态调整最快缓存的内容 把最近使用的指令保存在缓存是一种较好的最优化利用内存分层的策略 改变数据布局或计算次序也可以改进程序数据访问的时间和空间局部性

6.5 堆 管 理 例： 一个结构体大数组 分拆成若干个数组 struct student { int num[10000]; 6.5 堆 管 理 例： 一个结构体大数组 分拆成若干个数组 struct student { int num[10000]; int num; char name[10000][20]; char name[20]; … … … … } struct student st[10000]; 若是顺序处理每个结构体的多个域，左边方式的数据局部性较好 若是先顺序处理每个结构的num域，再处理每个结构的name域，…，则右边方式的数据局部性较好 最好是按左边方式编程，由编译器决定是否需要将数据按右边方式布局

6.5 堆 管 理 6.5.4 手工回收请求 程序员在程序中显式释放堆块来达到回收堆块的目的 内存泄漏：没有释放程序已经引用不到的堆块 6.5 堆 管 理 6.5.4 手工回收请求 程序员在程序中显式释放堆块来达到回收堆块的目的 内存泄漏：没有释放程序已经引用不到的堆块 只要内存没有用尽，它就不影响程序的正确性 自动无用单元收集通过回收所有无用单元来摆脱内存泄漏 悬空引用：引用已经被释放的堆块 过分热心地释放数据对象而引起 悬空引用容易导致不会被捕获的错误

本 章 要 点 影响存储分配策略的语言特征 各种存储分配策略，主要了解静态分配和动态栈式分配 活动记录中各种数据域的作用和布局 本 章 要 点 影响存储分配策略的语言特征 各种存储分配策略，主要了解静态分配和动态栈式分配 活动记录中各种数据域的作用和布局 非局部数据访问的实现方法 各种参数传递方式及其实现 堆管理

例 题 1 main() { char *cp1, *cp2; cp1 = "12345"; cp2 = "abcdefghij"; 例 题 1 main() { char *cp1, *cp2;   cp1 = "12345"; cp2 = "abcdefghij"; strcpy(cp1,cp2); printf("cp1 = %s\ncp2 = %s\n", cp1, cp2); } 在某些系统上的运行结果是： cp1 = abcdefghij cp2 = ghij 为什么cp2所指的串被修改了？

例 题 1 因为常量串“12345”和“abcdefghij”连续分配在常数区 执行前： 例 题 1 因为常量串“12345”和“abcdefghij”连续分配在常数区 执行前： 1 2 3 4 5 \0 a b c d e f g h i j \0   cp1 cp2

例 题 1 因为常量串“12345”和“abcdefghij”连续分配在常数区 执行前： 例 题 1 因为常量串“12345”和“abcdefghij”连续分配在常数区 执行前： 1 2 3 4 5 \0 a b c d e f g h i j \0   cp1 cp2 执行后： a b c d e f g h i j \0 f g h i j \0   cp1 cp2

例 题 1 因为常量串“12345”和“abcdefghij”连续分配在常数区 执行前： 例 题 1 因为常量串“12345”和“abcdefghij”连续分配在常数区 执行前： 1 2 3 4 5 \0 a b c d e f g h i j \0   cp1 cp2 执行后： a b c d e f g h i j \0 f g h i j \0   cp1 cp2 现在的编译器大都把程序中的串常量单独存放在只读 数据段中，因此运行时会报错

例 题 2 func(i,j,f,e) short i,j; float f,e; { short i1,j1; float f1,e1; 例 题 2 func(i,j,f,e) short i,j; float f,e; { short i1,j1; float f1,e1; printf(&i,&j,&f,&e); printf(&i1,&j1,&f1,&e1); } main() func(i,j,f,e); Address of i,j,f,e = …36, …42, …44, …54（八进制数） Address of i1,j1,f1,e1 = …26, …24, …20, …14

例 题 2 func(i,j,f,e) Sizes of short, int, long, float, 例 题 2 func(i,j,f,e) Sizes of short, int, long, float, short i,j; float f,e; double = 2, 4, 4, 4, 8 { （在SPARC/SUN工作站上） short i1,j1; float f1,e1; printf(&i,&j,&f,&e); printf(&i1,&j1,&f1,&e1); } main() { short i,j; float f,e; func(i,j,f,e); Address of i,j,f,e = …36, …42, …44, …54（八进制数） Address of i1,j1,f1,e1 = …26, …24, …20, …14

例 题 2 func(i,j,f,e) Sizes of short, int, long, float, 例 题 2 func(i,j,f,e) Sizes of short, int, long, float, short i,j; float f,e; double = 2, 4, 4, 4, 8 { （在SPARC/SUN工作站上） short i1,j1; float f1,e1; printf(&i,&j,&f,&e); printf(&i1,&j1,&f1,&e1); } main() 为什么4个形式参数i,j,f,e的地址 { 间隔和它们类型的大小不一致 short i,j; float f,e; func(i,j,f,e); Address of i,j,f,e = …36, …42, …44, …54（八进制数） Address of i1,j1,f1,e1 = …26, …24, …20, …14

例 题 2 当用传统的参数声明方式时，编译器不检查实参和形参的个数和类型是否一致，由程序员自己负责 但对形参和实参是不同的整型，或不同的实型 例 题 2 当用传统的参数声明方式时，编译器不检查实参和形参的个数和类型是否一致，由程序员自己负责 但对形参和实参是不同的整型，或不同的实型 － 编译器试图保证运行时能得到正确结果 － 条件是：若需数据类型转换时，不出现溢出 编译器的做法 － 把整型或实型数据分别提升到long和double类 型的数据，再传递到被调用函数 － 被调用函数根据形参所声明的类型，决定是 否要将传来的实参向低级别类型转换

例 题 2 低地址 放高位 高地址 放低位 short long 长整型和短整型 float double 双精度型和浮点型

例 题 2 在main函数中参数压栈时的观点 在func函数中存取形式参数时的观点 i，4个字节 2个字节，起始地址36 j，4个字节 例 题 2 e，8个字节 在main函数中参数压栈时的观点 在func函数中存取形式参数时的观点 4个字节，起始地址54 4个字节，起始地址44 2个字节，起始地址42 2个字节，起始地址36 f，8个字节 j，4个字节 i，4个字节 栈的增长方向 参数在栈中的情况

例 题 3 下面程序为什么死循环（在SPARC/SUN工作站上） ？ main() { addr(); loop(); } long *p; 例 题 3 下面程序为什么死循环（在SPARC/SUN工作站上） ？ main() { addr(); loop(); } long *p; loop() { long i,j;   j=0; for(i=0;i<10;i++){ (*p)--; j++; } } addr() { long k; k=0; p=&k;}

例 题 3 将long *p改成short *p，long k 改成short k 后，循环体执行一次便停止，为什么？ 例 题 3 将long *p改成short *p，long k 改成short k 后，循环体执行一次便停止，为什么？ main() { addr(); loop(); } short *p; loop() { long i,j;   j=0; for(i=0;i<10;i++){ (*p)--; j++; } } addr() { short k; k=0; p=&k;}

例 题 3 将long *p改成short *p，long k 改成short k 后，循环体执行一次便停止，为什么？ 例 题 3 将long *p改成short *p，long k 改成short k 后，循环体执行一次便停止，为什么？ main() { addr(); loop(); } short *p; 活动记录栈是从高向低方向增长 loop() { long i,j;   j=0; for(i=0;i<10;i++){ (*p)--; j++; } } addr() { short k; k=0; p=&k;} 低地址 放高位 高地址 放低位 short k long i

例 题 4 main() { func(); printf("Return from func\n"); } func() 例 题 4 main() { func(); printf("Return from func\n"); } func() { char s[4]; strcpy(s,"12345678"); printf("%s\n",s); } 在X86/Linux操作系统上的运行结果如下： 12345678 Return from func Segmentation fault (core dumped)

例 题 4 main() { func(); printf("Return from func\n"); } func() 例 题 4 main() { func(); printf("Return from func\n"); } func() { char s[4]; strcpy(s,"12345678"); printf("%s\n",s); } . . . 返址 控制链 变量s ebp esp 栈 低 高

例 题 4 main() { func(); printf("Return from func\n"); } func() 例 题 4 main() { func(); printf("Return from func\n"); } func() { char s[4]; strcpy(s,"123456789"); printf("%s\n",s); } 123456789 Segmentation fault (core dumped) . . . 返址 控制链 变量s ebp esp 栈 低 高

例 题 5 int fact(i) | main() int i; | { { | printf("%d\n", fact(5)); 例 题 5 int fact(i) | main() int i; | { { | printf("%d\n", fact(5)); if(i==0) | printf("%d\n", fact(5,10,15)); return 1; | printf("%d\n", fact(5.0)); else | printf("%d\n", fact()); return i*fact(i-1); | } } 该程序在X86/Linux机器上的运行结果如下： 120 1 Segmentation fault (core dumped)

例 题 5 请解释下面问题： 第二个fact调用：结果为什么没有受参数过多的影响？ 例 题 5 请解释下面问题： 第二个fact调用：结果为什么没有受参数过多的影响？ 第三个fact调用：为什么用浮点数5.0作为参数时结果变成1? 第四个fact调用：为什么没有提供参数时会出现Segmentation fault？

例 题 5 请解释下面问题： 第二个fact调用：结果为什么没有受参数过多的影响？ 例 题 5 请解释下面问题： 第二个fact调用：结果为什么没有受参数过多的影响？ 解答：参数表达式逆序计算并进栈，fact能够取到第一个参数

例 题 5 请解释下面问题： 第三个fact调用：为什么用浮点数5.0作为参数时结果变成1? 解答：参数5.0转换成双精 例 题 5 请解释下面问题： 第三个fact调用：为什么用浮点数5.0作为参数时结果变成1? 解答：参数5.0转换成双精 度数进栈，占8个字节 它低地址的4个字节看成整 数时正好是0 . . . 参数 返址 控制链 局部变量 ebp esp 栈 低 高

例 题 5 请解释下面问题： 第三个fact调用：为什么用浮点数5.0作为参数时结果变成1? 例 题 5 请解释下面问题： 第三个fact调用：为什么用浮点数5.0作为参数时结果变成1? IEEE standard 754存储方式（从高位到低位） float： 1位符号位，8位指数位，然后是23位尾数 double： 1位符号位，11位指数位，然后是52位尾数 5.0：0 00000000010 01000000000000000000…… 最高位1不写入内存

例 题 5 请解释下面问题： 第四个fact调用：为什么没有提供参数时会出现Segmentation fault？ 解答：由于没有提供参数， 例 题 5 请解释下面问题： 第四个fact调用：为什么没有提供参数时会出现Segmentation fault？ 解答：由于没有提供参数， 而main函数又无局部变量， fact把老ebp（控制链） （main的活动记录中保存 的ebp）当成参数，它一定 是一个很大的整数，使得活 动记录栈溢出 . . . 控制链 返址 局部变量 ebp esp 栈 低 高

习 题 6.9 6.17 6.18 6.20