从问题到程序——指针

Transcription

1 指针

2 地址与指针

3 3 内存地址 : 内存单元的编号 程序执行期间数据存放在内存区 : 有确定的存储位置, 且占据一定的内存单元 ; 机器语言通过地址访问数据, 高级语言将变量等作为存储单元 / 地址的抽象 ; 建立变量是分配存储单元, 赋值是将值存入单元, 取值是从单元中提取值 ; 任何变量在存在期间均有确定的存储位置, 有固定的地址 ( 寄存器变量除外 ); 内存的地址用固定长度的二进制编码, 可作为程序处理的数据 地址值 / 指针值

4 4 指针变量 ( 指针 pointer) 以地址为值的变量, 提供了一种访问其他对象的手段 ; 指针变量 p 变量 x 指针 p 指向 x 主要的指针操作 指针变量 p 指针赋值 : 将程序对象 ( 如变量等 ) 的地址存入指针变量 ; 或将一个指针的值赋给另一个指针变量 y ; 间接访问 : 通过指针访问被指向的对象 指针变量可赋值 变量 x

5 指针变量的定义和使用

6 6 定义指针变量 指针变量的类型 : 指针都有类型, 即只能保存特定类型的变量的地址 ; 指向 int 类型的指针 p:p 只能指向 int 变量 ;p 所指的总被认为是 int 变量 ; 从 p 间接访问的变量总被当成 int 变量 ; 简称 p 为整型指针, 其类型用 (int *) 表示 ; 定义形式 : 用类型名指明其指向对象的类型, 且变量名前加 * 号说明其为指针变量 ; 基类型 * 指针变量名 ; 例 :int *p, n, a[10], *q, *p1, m;

7 7 指针操作 取地址运算 : 一元运算符 & 优先级同其他一元运算符 ; 右结合 ; & 放在变量描述 ( 如变量名 ) 前取得变量地址 : 是对应类型的指针值, 可赋给类型合适的指针变量 ; p = &n; q = p; p1 = &a[1]; 指针变量 p 指针变量 q 变量 n 多个指针可能同时指向同一个变量 ; 指针变量相等说明两个指针指向程序里同一个对象 ( 相同的内存地址 )

8 8 指针操作 间接运算 : 一元运算符 * 优先级同其他一元运算符 ; 右结合 ; 运算对象是指针变量, 间接运算得到其所指变量 放在表达式中表示取被指变象的值参与运算 间接访问 ;(c.f. 直接访问 ) 放在赋值运算符左边表示给被指变量赋值 间接赋值 ;(c.f. 直接赋值 ) 间接赋值 :*p = 17; /* 写 *p 相当于直接写 n*/ 间接访问 :m = *p + *q * n; /* 将访问 n 三次 */

9 9 指针操作 例, 设 p 指向 n ++ *p; /* 使变量 n 的值加 1, 变成 18 */ (*p)++; /* 使 n 的值再加 1, 变成 19 */ *p += *q + n; /* n 被赋以新值 57 */ q = &a[0]; /* q 指向了数组 a 的元素 */ &*P 的含义? *&n 的含义?

10 10 指针作为函数参数 问题 : 定义函数 swap 交换两个参数的值 ; 需要同时改变两个变量, 无法通过返回值解决 ; void swap0 (int x, int y) { int t = x; x = y; y = t; } int f( ) { int a = 5, b = 10; swap0(a, b); /* 不行 */ }

11 值传递:单向传递11 指针作为函数参数 swap0 的 栈区 f 的栈区 t( 变量 ) x( 参数 ): 5(=a 的值 ) y( 参数 ): 10(=b 的值 ) 返回地址 ( 返回 f) f 的运行状态保护区 a( 变量 ): 5 b( 变量 ): 10 参数区返回地址调用函数的运行状态保护区 调用函数 swap0 时内存现场 ( 运行栈 )

12 12 指针作为函数参数 在函数 g 内部通过指针访问外部的变量 m: 将变量 m 的地址 ( 也是值 ) 通过指针参数 p 传给函数 g, 函数内部对 p 间接访问即可操作 m, 包括对 m 赋值 变量 m g 的函数体 指针参数 p 在函数体里通过 *p 可以 访问和改变实参变量 m.

13 13 指针作为函数参数 通过指针参数改变调用环境的方案 1. 函数定义中用指针参数 ; 2. 函数内通过指针参数间接访问所指变量 void swap(int *p, int *q) { ; 3. 调用时以被操作变量的地址作为实参 } 变量 m int t = *p; *p = *q; *q = t; swap 的函数体 int f( ) { 变量 nint m = 5, n = 10; swap(&m, &n); } p q

14 地址传递:双向传递14 指针作为函数参数 swap 的 栈区 f 的栈区 t( 变量 ) p( 参数 ): m 的地址 q( 参数 ): n 的地址返回地址 ( 返回 f) f 的运行状态保护区 m( 变量 ): 5 n( 变量 ): 10 参数区返回地址调用函数的运行状态保护区 调用函数 swap 时内存现场 ( 运行栈 )

15 指针作为函数参数 int getnumber(char prompt[], int imin, } 例 int, 修改上章的带检查的数据输入函数 i;, 引进一个指针参数 *np = 0; /*, 保证使之能更好的处理输入错误 *np 被赋值 */ int imax, int repeat, int *np) { for (i = 0; repeat<=0 i<repeat; ++i) { 通过指针参数返回所读入的数值 printf("%s", prompt); ; if (scanf("%d", np)!=1 用函数返回值传递函数执行的状态信息 *np<imin *np>imax) { : 返回 1 表示输入成功,0 表示输入未能正常完成 printf("correct range [%d, %d].\n", imin, imax); while (getchar()!= '\n') ; } else 调用实例 return 1; } if (getnumber("your guess: ", 0, m-1, return 0; 5, &guess) == 0) { /* 处理输入出错的程序片段 */ } 15

16 16 与指针有关的一些问题 空指针 特殊的指针值, 表示指针变量闲置 ( 即未指向任何变量 ); 唯一对任何指针类型都合法的指针值 ; 用 0 表示, 标准库定义与 0 等价的符号常量 NULL; 将指针 p 置为空指针 : p = NULL; /* 需包含某个标准头文件 */ p = 0;

17 17 与指针有关的一些问题 指针的初始化 定义指针变量时可以用合法的指针值初始化 int n, *p = &n, *q = NULL; 如未初始化, 外部和局部静态指针自动置为空指针 ; 普通局部指针不自动初始化, 其值不确定 ; 最常见的指针使用错误 非法间接访问 : 间接访问悬空指针 ( 未保存合法变量地址的指针变量 ); int swap(p, f (...) { 注意 :&n); 间接访问其值为空指针的指针是非法的 /* 有些系统可能给出 warning */ int *p, n = 3; scanf(..., p); /* 编译时不能发现 scanf 的错误 */ *p = 2; /* 注意 :p 没有初始化, 没有指向合法变量 */ scanf("...", } n);

18 18 与指针有关的一些问题 通用 (void) 指针 类型 : (void *), 可指向任何类型的变量 ; 定义 : void *gp1,*gp2; 任何指针值 / 变量的地址可不必转换赋给通用指针 : gp1 = &n; /* gp1 指向 n( 值是 n 的地址 )*/ gp2 = &x; /* gp2 指向 x( 值是 x 的地址 )*/ gp1 = &n; 可以把通用指针的值赋给普通指针 规定 : 如果通用指针 gpt 指向变量 g, 且 g 的类型是普通指针 pt 的指向类型, 则将 gpt 的值强制转换后赋值给 pt 后, 通过 pt 保证正确访问 g p = (int *)gp1; /* 合法,p 是 (int*) */ q = (double*)gp1; /* 不合法,q 是 (double*) */

19 19 与指针有关的一些问题 通用 (void) 指针 指针类型代表一种观点 : 被整型指针指向的对象总被看成是整型变量 ; 被双精度指针指向的对象总被看成是双精度变量 ; 指针转换不是改变指针值, 而是观点的转换 : 如从整型指针转换到通用指针时将丢掉类型信息 ; C 语言保证 : 如果恢复到原有的类型 ( 从通用指针转回整型指针 ), 被指对象还可以正常使用 ; 通用指针不能够做间接运算, 主要用途是保存和提供指针值

20 指针与数组

21 21 指向数组元素的指针 类型合适的指针可指向数组元素 : int *p1, *p2, *p3, *p4; int a[10] = {1,2,3,4,5,6,7,8,9,10}; p1 = &a[0]; p2 = p1; P3 = &a[5]; p4 = &a[10]; p1 p2 p3 p4 数组 a p4 指向 a 最后元素向后的一个位置 ;C 语言保证这个地址存在, 但写 *p4 是错误的

22 22 数组名求值 sizeof( 数组名 ): 返回整个数组所占用内存的字节数 ; & 数组名 : 返回一个指向数组的指针 ; 其他表达式 : 数组名的值是一个指向数组首元素的指针常量, 其类型取决于数组元素的类型 ; 数组名不是指针变量, 不能被修改, 不可单独出现在赋值运算符 ( 或其它更新运算符 ) 的左侧 ; a++; a += 3; a = p;

23 23 数组名求值 m m[1] int a[10], *p1, *p2; p1 = a; /* 等价于 p1 = &a[0]; */ p2 = &a; /* &a 返回指向包含 10 个整型元素的数组的指针 */ int m[3][10]; 表达式 m 返回一个指向包含 10 个整型元素的数组的指针 ; 表达式 m[1] 返回一个指向整型的指针

24 24 指针运算 通过指针访问数组元素须保证不越界! 指针运算 : 由指针值出发进行的运算 p1 数组 a 当指针 p 指向数组元素时 (p 指在数组里 ): 通过 p 不仅可访问 p 所指的元素, 还可访问数组中的其他元素 p1+1 p1+4 p2-3 p2 *(p1 + 2) = 3; p2 = p1 + 5; *(p2 + 2) = 5; *(p2-2) = 4; p3 = p2; ++p3; p3 += 2; p1+9 p2+2

25 25 指针运算 指在同一个数组里的两个指针 可求差得两者之间数组元素的个数 ( 带符号整数 ) 可比较大小 n = p2 p1; /* 也可求 p1 p2 */ if (p2 > p1)... 当 p2 所指的元素在 p1 所指的元素之后时条件成立 ( 值为 1), 否则不成立 ( 值为 0); 如两个指针不指在同一数组里, 比较大小无意义

26 26 指针运算 指针的比较 : 相等 (==) 和不等 (!= ) 两个指针相等的含义 : 它们指向同一数据元素或同为空值 ; 同类型指针可进行比较 ; 任何指针都可与通用指针 以及空指针值 (0 或 NULL) 比较 ; 注 1: 通用指针可与任何指针比较相等 / 不等 / 大小 ( 如果指在同一数组里 ), 但不能作加减等其他指针运算 ; 注 2: 数组名可参与一些指针运算 ( 大小比较 / 相等 / 不等 ), 但某些不赋值的指针运算可能得到不合法的指针值 ( 结果超出数组界限 )

27 28 数组写法与指针写法 如果指针指在数组里, 通过指针访问数组元素也可用下标形式描述 p1[3] = 5; p3[2] = 8; *(p1 + 3) = 5; *(p3 + 2) = 8; 数组写法 :p[3] 一类的写法 ; 指针写法 :*(p + 3) 一类的写法 ; p 可以是数组名或指在数组里的指针变量 ; 两种写法有等价效力, 可自由选用择 问题 :b[i][j] 的指针写法?

28 29 数组参数的意义 C 规定函数的数组参数即是相应类型的指针参数 : 数组参数是利用指针实现的, 因而采用数组参数的函数能修改实参数组 ; int f(int n, int d[]) {......} int f(int n, int *d) {......} 函数体内也可用指针写法做数组元素访问 ; 函数里不能用 sizeof 确定实参数组的大小 : 函数的数组形参实际是指针参数, 用 sizeof 算出的是指针变量的大小

29 30 基于指针运算的数组程序设计 问题 : 设有 int 数组 a 和指针 p1 p2, 打印 a 的元素 1. for (p1 = a, p2 = a+10; p1 < p2; ++p1) printf("%d\n", *p1); 2. for (p1 = a; p1 < a+10; ++p1) printf("%d\n", *p1); 3. for (p1 = p2 = a; p1 - p2 < 10; ++p1) printf("%d\n", *p1); 4. for (p1 = a; p1 - a < 10; ++p1) printf("%d\n", *p1);

30 31 实例 1: 字符串长度函数 int strlength (const char *s) { int n = 0; while (*s!= '\0') { s++; n++; } return n; } int strlength (const char *s) { char *p = s; while (*p!= '\0') p++; return p - s; }

31 32 实例 2: 字符串复制函数 void strcopy (char *s, const char *t) { while ((*s = *t)!= '\0') { s++; t++; } } void strcopy (char *s, const char *t) { while (*s = *t) { s++; t++; } } void strcopy (char *s, const char *t) { while (*s++ = *t++) ; // 空语句 }

32 33 实例 3: 数组处理函数 1) 输出 int 数组里一段元素 : void prt_seq(int *begin, int *end) { for (; begin!= end; ++begin) printf("%d\n", *begin); } prt_seq(a, a+10); prt_seq(a+5, a+10); prt_seq(a+4, a+4); prt_seq(a+10, a+10); 2) 设置 函数 : void set_seq(int *b, int *e, int v){ for (; b!= e; ++b) *b = v; }

33 34 实例 3: 数组处理函数 3) 序列中每个元素都用其平方根取代 : void sqrt_seq (double *b, double *e){ for (; b!=e; ++b) *b = sqrt(*b); } 4) 求平均值 : double avrg(double *b, double *e) { double *p, x = 0.0; if (b == e) return 0.0; for (p = b; p!= e; ++p) x += *p; return x / (e - b); }

34 35 字符指针与字符数组 字符指针常被用来指向字符数组中的元素 ; 定义字符指针时可用字符串常量初始化 ; char *p = "Programming"; 1. 定义字符指针 p; 2. 建立字符串常量 Programming ; 3. 令 p 指向字符串常量 指针 p p r o g r a m m i n g \0 c.f. char a[] = "Programming"; 数组 a p r o g r a m m i n g \0

35 36 字符指针 vs. 字符数组 1. p 可以被重新赋值, 改变所指的对象 ;a 的存储区域固定, 不能赋值 ; p = "Programming Language C"; 2. p 和 a 的类型不同, 大小不同 :p 通常用一个机器字表示 ;a 占据 12 个字符的空间 ; 3. a 的元素可以被重新赋值 ; a[8]='e'; a[9]='r'; a[10]='\0'; C 语言规定 : 不能修改字符串常量!

36 37 字符指针与字符数组 实例 : 利用字符指针读入一行字符到数组 enum { NLINE = 256 }; char line[nline]; int count; char *p; /* */ p = line; while(p line<nline-1 && (*p = getchar())!='\n') ++p; *p = '\0'; /* 做成字符串 */ /* */ for (count = 0, p = line; *p!= '\0'; ++p) if (*p == 'e') ++count; /* 统计 e 的个数 */

37 指针数组

38 39 字符指针数组 定义 : 运算符优先级适用于定义和声明,[] 的优先级高 ; char *pa[10]; 初始化 : 定义字符指针数组时可用字符串常量提供初始值 ; char *keywords[] = { "auto", "break", "volatile", "while" }; printf("%s %s\n", keywords[0], keywords[1]);

39 40 字符指针数组 vs. 两维字符数组 char color1[][6] = {"RED","GREEN","BLUE"}; char *color[] = {"RED","GREEN","BLUE"}; 数组 color1 R E D \0 \0 \ 0 G R E E N \0 B L U E \0 \0 指针数组 color R E D \0 (a) G R E E N \ 0 B L U E \0 (b)

40 41 命令行参数 命令行是用来启动程序的字符行 : 包含命令名 ( 可执行程序的名字 ), 以及其他启动程序所需的信息 ; 在图形用户界面系统中, 命令行位于图标 / 菜单的定义 ; edit file1.txt dir \windows\system /p abcd(abcd.c abcd.exe) C 程序将命令行看成由空格分隔的字段, 每一段对应一个命令行参数 : 命令名编号为 0, 其余参数依次编号 ; 程序启动时将各命令行参数做成字符串 ; 程序里可按规定方式使用和处理各参数

41 42 命令行参数 C 程序通过 main 的参数获取 / 处理命令行参数 int main (int argc, char *argv[]); argc 代表命令行参数的个数 ; argv 是一个有 argc + 1 个字符指针的数组 : 前面 argc 个指针指向各命令行参数字符串, 最后一个是空指针 ; main 函数由系统调用 ; 即 main 函数的实参不是在程序中给出, 而是在执行程序时给出

42 43 命令行参数 5 argc argv 函数 main 命令行 prog1 there are five arguments 的执行现场 p r o g 1 \0 t h e r e \0 a r e \0 f i v e \0 a r g u m e n t s \0 0 空指针

43 44 命令行参数 例 : 写程序 echo 打印各命令行参数 #include <stdio.h> int main (int argc, char *argv[]) { int while i; (*argv!= NULL) for (i = 0; i < argc; ++i) printf("args[%d]: printf( %s\n, *argv++); %s\n", i, argv[i]); return 0; } P237 echo 程序实例演示

44 多维数组作为参数的通用函数

45 46 二维数组作为函数的参数 int fun1(int n, int mat[][10]) { mat[i][j] } void fun2(int m, int n, int mat[][]) 数组 int mat[10][8]: 首个基元素的位置是 &mat[0][0]; 每一行有 8 个基元素 ( 整数 ); 第 1 行的起始位置是 &mat[0][0]+8, 用表达式 *(&mat[0][0]+8) 可以访问第 1 行首元素 ; 用 *(&mat[0][0]+i*8) 可以访问第 i 行的首元素 ; 用 *(&mat[0][0]+i*8+j) 可以访问 mat[i][j]

46 47 解决思路 函数处理两维数组所需的信息 1. 基本元素的类型 ; 2. 数组的内存起始位置 ; 3. 数组两个维的长度 ; 数组参数 长度参数 三方面信息均可通过参数传递

47 48 实例 写通用函数输出两维整型数组, 每行输出在一行 void prtmatrix (int m, int n, int *mp){ int i, j; for (i = 0; i < m; ++i) { for (j = 0; j < n; ++j) printf("%d ", *(mp + i * n + j)); putchar('\n'); } prtmatrix(10, 8, a);? } prtmatrix(10, 8, a[0]);? prtmatrix(10, 8, &a[0][0]); prtmatrix(20, 36, &mat[0][0]);

48 动态存储管理

49 50 C 程序中变量的存储分配 共同性质 变量的存储大小是静态确定的 外部变量 局部静态变量 : 在编译时确定存储分配, 开始执行前完成分配 ; 自动变量 : 在程序执行到定义所在的函数 / 复合语句时分配存储 ; 变量和参数决定了函数执行时所需的存储空间, 且可在编译时确定 ; 静态处理存储的优点是方便 / 效率高, 执行时工作简单 / 速度快 ; 但对编程方式加了限制

50 51 学生成绩实例 问题 : 能否实现先输入数据的项数, 再据此建立数组? int n;... scanf("%d", &n); double scores[n];... /* 读入数据, 然后处理 */ 问题的实质 : 在编写程序时可能无法确定对存储的需求量

51 52 动态存储分配与释放 动态存储分配 : 程序运行中根据需求动态的分配存储 ; 程序里用指针指向动态分配的存储块, 通过指针的间接操作可使用所指的存储块 ; 动态释放 : 不再使用的动态分配的存储块应交还系统 ; 动态存储管理系统 : 完成动态分配 / 释放工作 ; 是程序运行系统的子系统, 管理称作堆 (heap) 的一片存储区 <stdlib.h>

52 53 存储分配函数 malloc void *malloc(size_t ns); /* size_t 是某整型 */ 功能 : 分配一块不小于 ns 的连续存储, 并返回其地址 ; 如申请未成功即返回空指针值 int n; double *data;... scanf("%d", &n); data = (double*) malloc(n * sizeof(double)); if (data == NULL) {... /* 分配未完成时的处理 */ }..data[i]..*(data+j)../* 正常处理 */

53 54 malloc 函数的说明 size_t: 标准库中定义的一种数据类型, 是某种无符号整型 ; 具体类型由具体的 C 系统确定 ; 是 sizeof 的返回值类型 ; malloc 的返回值 (void *) 需通过强制类型转换成特定指针类型后, 再赋值给指针变量 ; 计算所要分配的存储块大小时应使用 sizeof, 不应该直接写数值 ; 动态分配必须检查分配成功与否 ; 动态分配的存储块大小是确定的, 越界使用 ( 尤其是越界赋值 ) 是非法的

54 55 带计数和清 0 的存储分配函数 calloc void *calloc(size_t n, size_t size); 其中,size 是数据元素大小,n 是元素个数 功能 : 分配足够存放 n 个大小为 size 的元素的连续存储块, 并把存储块全部初始化为 0; 如无法分配时返回空指针值 ; data = (double*) calloc(n, sizeof(double));

55 56 动态存储释放函数 free void free(void *p); 功能 : 释放指针 p 所指的存储块 ( 必须是通过动态存储分配得到 );p 值为空指针时什么也不做 ; int fun (...) { int *p;... p = (int *)malloc(...);... free(p); return...; }/* 退出函数前应释放函数内分配且已无用的动态存储 */

56 57 free 函数的说明 执行 free(p) 后不改变 p 的值, 但被指块内容可 能已变, 因此不允许间接访问已释放的存储块 ; 不可以对非指向动态分配存储块的指针使用本操作 ; 动态存储块的释放只可通过调用 free 完成 ; 为保证动态存储区的有效使用, 不再使用的动态分配块时应该及时释放 ; 动态存储的流失 : 如程序长期执行, 存储流失可能成为严重的问题

57 58 分配调整函数 realloc void *realloc(void *p, size_t n); 其中,p 指向原动态分配块,n 是新的大小要求 功能 : 更改已有的分配, 返回大小至少为 n 的存储块的指针 ; q = (double*)realloc(p, m * sizeof(double)); if (q == NULL) { } /* 特殊处理 : 分配未成功,p 仍指原块 */ else { } 如果无法分配则返回空指针, 原块不变 ; 如果成功分配后, 新块与原块的内容一致, 而 p 原块的内容可能改变 = q; /* 令 p 指向新块 :, 正常处理新块较小时保存原块 */... n 范围内的数据 ; 新块较大时原数据存在前部, 新增加的部分不初始化

58 59 realloc 函数的说明 缩小 : 从原存储块的尾部截掉并回收多余部分, 块的起始位置和保留部分的内容不变 ; 扩大 : 如果原存储块之后有足够多的可用内存, 新分配块 = 原块 + 扩大部分, 块的起始位置和原块的内容不变, 扩大部分不初始化 ; 如果原存储块之后没有足够多的可用内存, 则重新申请内存 : 如申请成功, 复制数据至新块的前部, 返回新块地址并自动释放原块 ; 如果申请失败, 返回 NULL, 保持原块内容不变 ( 即不释放 不复制, 无用时需显式 free 原块 )

59 60 realloc 函数的说明 传递给 realloc 的指针必须是一个通过 malloc,calloc 或 realloc 返回的指针 ; 不能对指向动态分配块中的其他位置的指针调用 realloc 和 free; 不能对指向非动态分配块的指针 ( 数组名 指向字符串常量的指针等 ) 调用 realloc 和 free; char *buff; buff = (char *)malloc(100); buff += 50; free(buff); realloc(null, n) 等价于 malloc(n); realloc(p, 0) 等价于 free(p);(c99 有新规定 )

60 61 常见的动态内存错误 1. 未检查所请求内存是否成功分配 ; 2. 操作动态分配时超出了所分配内存的边界 ; 3. 释放并非动态分配的内存 : 传递给 free 的指针必须是一个从 malloc calloc 或 realloc 函数返回的指针 ; 4. 试图释放一块动态分配的内存的一部份 (realloc 函数可能缩小一块动态分配的内存, 有效释放其尾部的部分内存 ); 5. 继续访问已经被 free 函数释放的内存

61 62 实例 1: 修改筛法程序 要求 : 由命令行参数获得所需的范围 ; 如无命令行参数则要求用户输入确定范围的整数值 ; 工作一 : 将命令行参数 ( 字符串 ) 转换成整数 ; int s2int(const char *s) { int n; for (n = 0; isdigit(*s); ++s) n = 10 * n + (*s - '0'); return n; }

62 63 实例 1: 修改筛法程序 工作二 : 用函数封装筛法计算 void sieve(int lim, int an[]) { 工作三 : 主函数的工作内容 // 函数体的实现略, 类似于 p182 的主函数 // 只涉及筛法算法, 不涉及空间管理 1. 由命令行参数或用户输入获取范围 ; } 2. 分配空间及初始化 ; 3. 执行筛法 ; 4. 打印输出 ; 5. 释放空间

63 enum { LARG = }; int main(int argc, char **argv) { int i, j, n, *ns; /* 通过命令行参数或者用户输入获取范围 */ if (argc == 2) n = s2int(argv[1]); else getnumber("largest: ",2,LARG,5,&n); if (n < 2 n > LARG) { printf("largest must in [2, %d]",larg); return 1; } ns = (int*) malloc(sizeof(int)*(n+1))/* 分配 */ if (ns == NULL) { /* 检查分配是否成功 */ printf("no enough memory!\n"); return 2; } sieve(n, ns);... /* 输出略 */ free(ns); /* 释放 */ return 0; } 64

64 65 实例 2: 改造成绩直方图程序 要求 : 程序能处理任意多个成绩数据 ; 问题 : 如何处理事先无法确定数目的数据集合? double* readscores(int* np); int 函数 main(){ readscores 根据需求申请动态分配存储块, 并返回分配的块和实际项数 int n; : 通过 np 返回项数, double 无法得到存储时返回 *scores = readscores(&n); NULL; 如已读部分数据后扩大存储失败 if(scores ==, NULL) 给出提示信息并返回部分 return 1; 数据 ; }... /* 其他不必修改 */

65 enum { INUM = 40 }; double* readscores(int* np) { unsigned size = INUM, n; double *q, x, *p; if((p=(double*)malloc(inum*sizeof(double)))==null) { printf("no memory. Stop\n"); *np = 0; return NULL; } for(n=0; scanf("%lf", &x) == 1; ++n) { if (n == size) { /* 块满了, 需要重新分配 */ size *= 2; q = (double*)realloc(p, size*sizeof(double)); if (q == NULL) { printf("process only %d scores.\n", n); break; } p = q; } p[n] = x; } *np = n; return p; } 66

66 67 实例 2: 改造成绩直方图程序 readscores 函数的另一种实现方案 函数返回值为存储块的大小, 无法完成时返回 0; 通过参数获得动态存储块的地址 (double *), 实参应该是 (double *) 变量的地址, 而形参就应该是指向 (double *) 类型的指针, 即 (double **) 类型 ; 函数原型 :int readscores(double** dpp); 调用方式 :if(readscores(&scores)==0){ }

67 68 总结 : 关于动态存储分配 计算机系统的内存由 OS( 操作系统 ) 管理 : 启动一个程序时,OS 为其分配内存以存放代码和数据 ; 程序结束时 OS 收回该程序占用的所有内存 ; C 程序启动时从 OS 得到内存, 其中的动态存储区由该程序的动态存储管理系统管理 程序运行中调用 malloc 函数将从中分配存储,free 函数把不用的内存块退回动态存储管理系统 ( 分配和释放属于 C 程序内部事务 ); C 程序结束时,OS 收回原先分配给该程序的全部内存 ( 这属于 OS 的存储管理问题, 与 C 程序无关 ); 存储流失是 C 程序内部问题, 非 OS 的问题

68 定义类型

69 70 定义类型 形式 : 由关键字 typedef 引导, 其后的描述形式与变量定义类似, 而原变量名位置的标识符即是新的类型名 ; 作用一 : 简化程序书写 typedef unsigned long int ULI; ULI x, y, *p; p = (ULI *)malloc(n * sizeof(uli)); 作用二 : 提高程序的可读性和清晰性 typedef double LENGTH; typedef double AREA;

70 71 定义数组类型 例 1:4 个元素的双精度数组类型 typedef double VECT4[4]; VECT4 v1, v2; /* 定义两个 4 元素的双精度数组 */ int f(vect4 v, VECT4 u); 例 2:5x5 的双精度数组类型 typedef double MAT[5][5]; MAT a1, a2, a3; /* 定义 5 5 数组变量 */ double det(mat m); /* 说明函数参数 */ MAT *p = (MAT *)malloc(sizeof(mat));

71 72 定义指针类型 例 : typedef int * IP; /* 整型指针类型 */ typedef MAT * MATP; /* MAT 类型的指针类型 */ 如用宏定义实现, 可能有意外的结果, 例 #define MIP int * MIP mp1, mp2; /* 希望定义两个指针 */ 注意 : 展开后 mp2 不是指针, 而是 int 变量 ; 宏是低级正文代换机制, 应尽量少用 ; 需要定义类型名时, 应该使用 typedef

72 73 复杂类型描述与解读 类型描述中可能的成份 1. 已有的类型名 (int,char,double 等 ); 2. 被定义的标识符 ( 类型名 ); 3. 构造符号 ( 三个 / 组运算符 ): *- 指针 []- 数组 ()- 函数 4. 可加圆括号改变结合关系 ; 解读规则 : 符号的意义不变, 优先级和结合关系依据运算符的规定 ; 解读方式 : 先确认被声明 / 定义的标识符, 从其向外分析 ( 先右后左 )

73 74 复杂类型描述与解读 例 1:int *f(int); 声明 f 是函数 : 有一个 int 参数 返回 int 指针值 ; 例 2:int (*fp)(int); 声明 fp 是指针 : 指向一个 int 参数并返回 int 值的函数 ; 例 3:char **argv; 声明 argv 是指针 : 指向 (char *);

74 复杂类型描述与解读 try: 75 例 4:int (*dp)[16]; 例 6: int (*(*g(int))[4])(double); 声明 dp 是指针 : 指向一个 16 个元素的整型数组 ; 例 5:int *dp1[16]; 声明 dp1 是数组 :16 个元素, 元素是 int 指针 ; 声明 g 是一个函数 : 一个整型参数, 返回指针值 ; typedef int (*funp)(double); g 返回的指针值指向 4 个元素的数组 ; 数组中的每个元素是指针 typedef funp fparray[4]; ; 每个指针元素指向一个函数 Fparray *g(int); : 一个双精度参数并返回整数值

75 指向函数的指针

76 77 函数指针 C 语言提供指向函数的指针 ( 函数指针 ), 可以通过函数指针参数传递被处理的函数, 不同的调用传递不同的函数 ; 函数指针有类型 : 一个函数指针只能指向某种特定类型 ( 即具有特定原型 ) 的函数 ; 定义带函数指针参数的函数, 首先需要定义函数指针类型 ; typedef double (*MFP)(double); typedef double*(*funp)(int, int);

77 78 函数指针变量的定义和赋值 用函数指针类型定义指针变量 MFP p1, p2; double (*p1)(double),(*p2)(double); 给函数指针变量赋值 :C 语言规定, 对函数名求 值即可得到指向该函数的指针值, 可赋给类型合适的函数指针变量 ; 库函数和自定义函数均可赋值给类型合适的函数指针变量

78 79 函数指针变量的使用 例 :p1 = sin; 函数指针可以直接作为函数名使用 : x = p1(3.24);( 相当于 :x = sin(3.24);) 也可以写间接操作 : x = (*p1)(3.24);/* 注意括号 */ 说明 1: 通过函数指针调用函数, 被调的函数由函数指针当时的值决定 ; 即同样语句在不同时刻可能调用不同的函数 ; 说明 2: 绝不能调用悬空的函数指针!

79 函数指针作为函数参数 函数求根问题 y = : root(fun, 以函数指针作为求根函数的参 1.26, 7.03); 数, 重新定义弦线法求函数根的函数 : double cross(mfp fp, double x1, double x2) { double y1 = fp(x1), y2 = fp(x2); return (x1 * y2 - x2 * y1)/(y2 - y1); } double root(mfp fp, double x1, double x2) { double x, y, y1 = fp(x1); do { x = cross(fp, x1, x2); y = fp(x); if (y * y1 > 0.0) { y1 = y; x1 = x; } else x2 = x; } while (y >= 1E-6 y <= -1E-6); return x; } 函数调用实例 ( 设 fun 是类型合适的函数 ): x = root(sin, 0.4, 4.5); 80

80 81 实例 : 数值积分函数 分析 函数有 3 个参数 : 一个指向被积函数的函数指针参数 ; 两个表示积分上下限的 double 参数 ; 函数的返回值为双精度值 ; 用区域分割法逼近积分值 ( 矩形法 / 梯形法等 ); enum { DIVN = 30 }; double numint(mfp fp, double a, double b) { double res = 0.0, step = (b - a) / DIVN; int i; for (i = 0; i < DIVN; ++i) res += fp(a + i * step) * step; return res; }

81 82 实例 : 数值积分函数 double numint(mfp fp, double a, double b) { long i, divn = 10; double step, dif, res0, res; res = (fp(b)+fp(a))*(b-a)/2; } for (dif=1.0; fabs(dif)>1e-6; divn*=2) { res0 = res; step = (b - a) / divn; for (res=0.0, i=0; i<divn; ++i) res += fp(a + i*step) * step; dif = res - res0; } return res;

82 83 以函数指针为参数的数组操作实用函数 数组元素变换函数 对整个数组或其中一段元素做 变换, 将各元素修改为由它们算出来的某个值 void tran_double(double *b,double *e,mfp fp) { } for ( ; b!= e; ++b) *b = fp(*b); 调用实例 : 将 double 数组 a 前 20 个元素改为对应的平方根 tran_double(a, a+20, sqrt);

83 以函数指针为参数的数组操作实用函数 找 不匹配 目标 : 逐个比较两个 int 数组的元素, 找出第一对 不匹配 的元素 ; 可将元素的匹配方式参数化 ; 即定义 不匹配 查找函数 : 返回前一数组中不匹配元素的位置 ( 指针 ), 找不到就返回 end 的值 ; 假定匹配判断函数参数 fp 在匹配时返回非 0 值 ; int* mismatch(int *b1, int *e1, int *b2, int (*fp)(int, int)) { } for ( ; b1!= e1; ++b1, ++b2) if (fp(*b1, *b2) == 0) break; return b1; 84

84 以函数指针为参数的数组操作实用函数 使用实例 1: 匹配方式为数值相等 85 int equal(int m, int n) { return m == n; } int *p = mismatch(a, a+20, b, equal); 使用实例 2: 匹配方式为奇偶性相同 int parity(int m, int n) { return m%2==n%2;} Int *q = mismatch(a, a+30, b, parity);

85 86 本章要点 指针的概念 定义和基本操作 ; 以指针为参数的函数 特别是通过指针参数从函数里向外传递信息 ( 三个要素 ); 指针与数组的关系, 指针运算 ( 指针算术 ); 动态存储分配的基本技术 ; 指向函数的指针 ; 类型描述和解读,typedef; 指针参数和命令行参数