PowerPoint Presentation

Size: px

Start display at page:

Download "PowerPoint Presentation"

冽和
5 years ago
Views:

1 程序设计 II 计算机学院黄章进

2 课程内容 C 程序设计实践 C 语言回顾简单程序设计数制转换日期和时间处理, 等字符串处理高精度计算枚举 C++ 语言从 C 到 C++ 类与对象运算符重载与类型转换继承与虚函数编码规范 2

3 教材李文新, 郭炜, 余华山. 程序设计导引及在线实践, 清华大学出版社, 2007 C99 参考书 : K. N. King. C Programming: A Modern Approach, 2nd Edition, 2008 C 语言程序设计 : 现代方法 ( 第 2 版 ) 3

4 考核平时成绩 :40% 到课实验 : 西区电 3 楼 406 室 18:00-21:00 期末考试 :60% 7 月 29 日下午课程主页 : 4

5 程序设计 II 第 1 讲 C 语言回顾计算机学院黄章进 zhuang@ustc.edu.cn

6 内容 C 语言概述输入输出位运算函数指针 C99 的一些新特性命令行参数库函数动态内存分配 6

7 C 程序程序 = 数据结构 + 算法 C 语言概述 C 程序 = 变量 / 常量 + 函数 C 程序设计 C 标准 K&R C:Kernighan and Ritchie, The C Programming Language (1978) C89/C90:ISO/IEC 9899:1990 C99:ISO/IEC 9899:1999 C11: ISO/IEC 9899:2011 7

8 变量与数据类型 C 语言概述变量是内存中的一块区域变量名变量类型数据类型 : 内存取值操作 void 布尔型 _Bool 无符号整型, 取值 0 或 1,C99 bool (true/false) C99 <stdbool.h> 宏字符型 char 整型 signed char, short, int, long, long long unsinged char/short/int/long, unsigned long long 浮点型 float, double, long double 8

9 数据类型 C 语言概述自定义类型指针 NULL, void * 数组字符数组枚举 enum 整型结构体 struct 共用体 union 9

10 函数与语句 C 语言概述函数 ( 或程序 ) 的基本单元是语句 (statement) 函数自定义函数库函数语句空语句 ; 和 {} 声明语句表达式语句分支语句 if-else 语句, switch-case 语句循环语句 for 语句 while 语句 do-while 语句 break, continue, goto 语句语句块 10

11 表达式与运算符 C 语言概述将变量常量等用运算符 (operator) 连接在一起, 就构成了表达式 (expression) 运算符 : 目数优先级结合性 sizeof, &, * 算术运算符 :++, --, *, /, %, +, - 位运算符 :<<, >>, ~, &, ^, 关系运算符 :<, <=, >, >=, ==,!= 逻辑运算符 :!, &&, 条件运算符 :?: 赋值运算符 :=, 复合算术 / 位运算赋值逗号运算符 11

12 12

13 输入输出语句 C 语言通过库函数来支持输入输出输入输出 #include <stdio.h> scanf( ) 将输入读入变量 printf( ) 将变量内容输出 13

14 scanf( ) 函数 int scanf( const char *,...); 输入输出参数可变的函数第一个参数是格式字符串, 后面的参数是变量的地址, 函数作用是按照第一个参数指定的格式, 将数据读入后面的变量 14

15 scanf 返回值输入输出 >0 成功读入的数据项个数 0 没有项被赋值 EOF 第一个尝试输入的字符是 EOF( 结束 ) ( 对某些题, 返回值为 EOF 可以用来判断输入数据已全部读完 ) Number of receiving arguments successfully assigned, or EOF if read failure occurs before the first receiving argument was assigned. 15

16 printf( ) 函数输入输出 int printf( const char *,...); 参数可变的函数第一个参数是格式字符串, 后面的参数是待输出的变量, 函数作用是按照第一个参数指定的格式, 将后面的变量在屏幕上输出返回值 : 成功打印的字符数返回负值为出错 16

17 格式字符串里的格式控制符号输入输出 %d 读入或输出 int 变量 %c 读入或输出 char 变量 %f 读入或输出 float 变量 %s 读入或输出 char * 变量 %lf 读入或输出 double 变量 %e 以科学计数法格式输出数值 %x 以十六进制读入或输出 int 变量 %I64d 读入或输出 int64 变量 (64 位整数 ) %p 输出指针地址值 %.5lf 输出浮点数, 精确到小数点后 5 位 17

18 例子输入输出 #include <stdio.h> int main() { int a; char b; char c[20]; double d = 0; float e = 0; int n = scanf("%d%c%s%lf%f", &a, &b, c, &d, &e); printf("%d %c %s %lf %e %f %d", a, b, c, d, e, e, n); return 0; } 18

19 结果 int n = scanf("%d%c%s%lf%f", &a, &b, c, &d, &e); printf("%d %c %s %lf %e %f %d", a, b, c, d, e, e, n); 输入输出 input: 123a teststring output: 123 a teststring e input: 123ateststring output: 123 a teststring e input: 123 a teststring output: 123 a e

20 例子输入输出 #include <stdio.h> int main() { int a, b; char c; char s[20]; int64 n = ; scanf("%d %c,%s%x%i64d", &a, &c, s, &b, &n); printf("%d %x %u %s %p %x %d %I64d", a, a, a, s, s, b, b, n); return 0; } input: -28 K,test ffee output: -28 ffffffe test 0012FF60 ffee

21 64 位整数类型 int64 输入输出 int64 是有符号 64 位整数类型, 范围为 -2^63 (-9,223,372,036,854,775,808) 到 2^63-1 (9,223,372,036,854,775,807), 存储空间占 8 字节用于整数值可能超过 int 数据类型支持范围的情况 int64 关键字和 %I64 标号是 Microsoft 实现专有的要用 64 位 int 的话, 标准 C(C99) 可用 long long 和 %lld 21

22 常见错误输入输出 #include <stdio.h> int main() { char * s; scanf( %s, s); } 错在何处? 错在 s 不知道指向何处, 往其指向的地方写入数据, 不安全 22

23 读取一行输入输出 char * gets(char * s); 从标准输入读取一行到字符串 s 如果成功, 返回值就是 s 地址如果失败, 返回值是 NULL 可以根据返回值是 NULL 判定输入数据已经读完调用时要确保 s 指向的缓冲区足够大, 否则可能发生内存访问错误 23

24 例子输入输出 #include <stdio.h> int main() { char s[200]; char * p = gets(s); printf("%s:%s", s, p); return 0; } input: Welcome to Beijing! output: Welcome to Beijing!:Welcome to Beijing! 24

25 sscanf 和 sprintf 函数输入输出 int sscanf(const char * buffer, const char * format[, address,...]); 和 scanf 的区别在于, 它是从 buffer 里读取数据 int sprintf(char *buffer, const char *format[, argument,...]); 和 printf 的区别在于, 它是往 buffer 里输出数据 25

26 例子输入输出 #include <stdio.h> int main() { int a,b; char c; char s[20]; char szsrc[] = "-28 K,test ffee "; char szdest[200]; int64 n = ; sscanf(szsrc, "%d %c,%s%x%i64d", &a, &c, s, &b, &n); sprintf(szdest, "%d %x %u %s %p %x %d %I64d", a, a, a, s, s, b, b, n); printf("%s", szdest); return 0; } output: -28 ffffffe test 0012FF60 ffee

27 位运算有时我们需要对某个整数类型变量中的某一位 (bit) 进行操作比如, 判断某一位是否为 1, 或只改变其中某一位, 而保持其他位都不变六种位运算符来进行位运算操作 : & 按位与按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 27

28 按位与位运算按位与运算符 & 是双目运算符功能是将参与运算的两操作数各对应的二进制位进行与操作, 只有对应的两个二进位均为 1 时, 结果的对应二进制位才为 1, 否则为 0 按位与运算通常用来将某变量中的某些位清 0 或保留某些位不变 28

29 按位与位运算如果需要将 int 型变量 n 的低 8 位全置成 0, 而其余位不变, 则可以执行 n = n & 0xffffff00; 也可以写成 : n &= 0xffffff00; 如果 n 是 short 类型的, 则只需执行 : n &= 0xff00; 如何判断一个 int 型变量 n 的第 7 位 ( 从右往左, 从 0 开始数 ) 是否是 1? 只需看表达式 n & 0x80 的值是否等于 0x80 即可 29

30 按位或按位或运算符 " " 是双目运算符位运算功能是将参与运算的两操作数各对应的二进制位进行或操作, 只有对应的两个二进位都为 0 时, 结果的对应二进制位才是 0, 否则为 1 例如 : 表达式的值是 23 21: : :

31 按位或位运算按位或运算通常用来将某变量中的某些位置 1 或保留某些位不变如果要将 int 型变量 n 的低 8 位全置成 1, 而其余位不变, 则可以执行 : n = 0xff; 31

32 按位异或位运算按位异或运算符 "^" 是双目运算符功能是将参与运算的两操作数各对应的二进制位进行异或操作, 即只有对应的两个二进位不相同时, 结果的对应二进制位才是 1, 否则为 0 例如 : 表达式 21 ^ 18 的值是 7( 即二进制数 111) 21: : ^18: 异或运算的特点 : 如果 a^b=c, 那么就有 c^b = a 以及 c^a=b 此规律可以用来进行最简单的加密和解密 32

33 按位非位运算按位非运算符 "~" 是单目运算符功能是将操作数中的二进制位 0 变成 1,1 变成 0 例如, 表达式 ~21 的值是无符号整型数 0xffffffea 21: ~21: 而下面的语句 : printf("%d,%u,%x",~21,~21,~21); 输出结果就是 : -22, ,ffffffea 33

34 左移运算符左移运算符 << 是双目运算符位运算计算结果是将左操作数的各二进位全部左移若干位后得到的值, 右操作数指明了要左移的位数左移时, 高位丢弃, 低位补 0 左移运算符不会改变左操作数的值 34

35 左移运算符位运算例如, 常数 9 有 32 位, 其二进制表示是 : 因此, 表达式 9<<4 的值, 就是将上面的二进制数左移 4 位, 得 : 即为十进制的 144 实际上, 左移 1 位, 就等于是乘以 2, 左移 n 位, 就等于是乘以 2 n 而左移操作比乘法操作快得多 35

36 例子位运算 #include <stdio.h> int main() { int n1 = 15; short n2 = 15; unsigned short n3 = 15; unsigned char c = 15; n1 <<= 15; n2 <<= 15; n3 <<= 15; c <<= 6; printf( "n1=%x,n2=%d,n3=%d,c=%x,c<<4=%d", n1, n2, n3, c, c << 4); } 上面程序的输出结果是 : n1=78000,n2=-32768,n3=32768,c=c0,c<<4=

37 例子 n1: n2: n3: c: 位运算 n1 <<= 15: ( 变成 78000) n2 <<= 15:,( 变成 ) n3 <<= 15: ( 变成 32768) c <<= 6; ( 变成 c0) c << 4 这个表达式是先将 c 转换成整型然后再左移 c<<4=

38 右移运算符位运算右移运算符 >> 是双目运算符计算结果是把 >> 的左操作数的各二进位全部右移若干位后得到的值, 要移动的位数就是 >> 的右操作数移出最右边的位就被丢弃对于有符号数, 如 long,int,short,char 类型变量, 在右移时, 符号位 ( 即最高位 ) 将一起移动, 并且大多数 C 编译器规定, 如果原符号位为 1, 则右移时高位就补充 1, 原符号位为 0, 则右移时高位就补充 0 38

39 右移运算符位运算对于无符号数, 如 unsigned long, unsigned int, unsigned short, unsigned char 类型的变量, 则右移时, 高位总是补 0 右移运算符不会改变左操作数的值实际上, 右移 n 位, 就相当于左操作数除以 2 n, 并且将结果往小里取整 -25 >> 4 = -2-2 >> 4 = >> 4 = 1 39

40 例子位运算 #include <stdio.h> int main() { int n1 = 15; short n2 = -15; unsigned short n3 = 0xffe0; unsigned char c = 15; n1 = n1>>2; n2 >>= 3; n3 >>= 4; c >>= 3; printf( "n1=%x,n2=%d,n3=%x,c=%x", n1, n2, n3, c); } 上面的程序输出结果是 : n1=3,n2=-2,n3=ffe,c=1 40

41 例子 n1: n2: n3: c: 位运算 n1 >>= 2: 变成 n2 >>= 3: 变成 n3 >>= 4: 变成 ffe c >>= 3; 变成

42 思考题有两个 int 型的变量 a 和 n(0 <= n <= 31), 要求写一个表达式, 使该表达式的值和 a 的第 n 位相同位运算答案 : ( a >> n ) & 1 或 : (a & (1 << n )) >> n 42

43 函数指针程序运行期间, 每个函数都会占用一段连续的内存空间而函数名就是该函数所占内存区域的起始地址 ( 也称入口地址 ) 可以将函数的入口地址赋给一个指针变量, 使该指针变量指向该函数然后通过指针变量就可以调用这个函数这种指向函数的指针变量称为函数指针 43

44 定义函数指针函数指针定义的一般形式为 : 类型名 (* 指针变量名 )( 参数类型 1, 参数类型 2, ); 类型名表示被指函数的返回值的类型 ( 参数类型 1, 参数类型 2, ) 中则依次列出了被指函数的所有参数的类型 int (*pf)(int, char); 表示 pf 是一个函数指针, 它所指向的函数, 返回值类型应是 int, 该函数应有两个参数, 第一个是 int 类型, 第二个是 char 类型 44

45 调用函数指针可以用一个原型匹配的函数的名字给一个函数指针赋值通过函数指针可调用它所指向的函数, 写法为 : 函数指针名 ( 实参表 ); 下面的程序说明了函数指针的用法 45

46 例子函数指针 #include <stdio.h> void PrintMin(int a, int b) { if( a<b ) printf("%d", a); else printf("%d", b); } int main(){ void (* pf)(int, int); int x = 4, y = 5; pf = PrintMin; pf(x, y); return 0; } 上面的程序输出结果是 : 4 46

47 快速排序库函数 qsort 函数指针 void qsort(void *base, int nelem, unsigned int width, int (*pfcompare)( const void *, const void *)); base 是待排序数组的起始地址, nelem 是待排序数组的元素个数, width 是待排序数组的每个元素的大小 ( 以字节为单位 ) pfcompare 是一个函数指针, 它指向一个比较函数该比较函数应是返回值为 int, 有两个参数为 const void * 的函数 47

48 比较函数函数指针排序就是一个不断比较并交换位置的过程 qsort 如何在连元素的类型是什么都不知道的情况下, 比较两个元素并判断哪个应该在前呢? 答案是,qsort 函数在执行期间, 通过 pfcompare 指针调用比较函数, 调用时将要比较的两个元素的地址传给比较函数, 然后根据比较函数返回值判断两个元素哪个更应该排在前面这个比较函数不是 C/C++ 的库函数, 而是由使用 qsort 的程序员编写的在调用 qsort 时, 将比较函数的名字作为实参传递给 pfcompare 48

49 比较函数函数指针 qsort 函数的用法规定, 比较函数的原型是 int 函数名 (const void * elem1, const void * elem2); 该函数的两个参数,elem1 和 elem2, 指向待比较的两个元素也就是说, * elem1 和 * elem2 就是待比较的两个元素该函数必须具有以下行为 : 如果 * elem1 应该排在 * elem2 前面, 则函数返回值是负整数 ( 任何负整数都行 ) 如果 * elem1 和 * elem2 哪个排在前面都行, 那么函数返回 0 如果 * elem1 应该排在 * elem2 后面, 则函数返回值是正整数 ( 任何正整数都行 ) 49

50 例子下面的程序, 功能是调用 qsort 库函数, 将一个 unsigned int 数组按照个位数从小到大进行排序比如 8,23,15 三个数, 按个位数从小到大排序, 就应该是 23,15,8 函数指针 #include <stdio.h> #include <stdlib.h> int MyCompare( const void * elem1, const void * elem2 ) { unsigned int * p1, * p2; p1 = (unsigned int *) elem1; p2 = (unsigned int *) elem2; return (* p1 % 10) - (* p2 % 10 ); } 50

51 例子函数指针 #define NUM 5 int main() { unsigned int an[num] = { 8,123,11,10,4 }; qsort( an, NUM, sizeof(unsigned int), MyCompare); for( int i = 0; i < NUM; i ++ ) printf("%d ", an[i]); return 0; } 上面程序的输出结果是 : 思考题 : 如果要将 an 数组从大到小排序, 那么 MyCompare 函数该如何编写? 51

52 C99 的一些新特性 for 语句数组初始化变长数组 main 函数 52

53 C99 中的 for 语句 for 语句的一般形式 : for ( expr1 ; expr2 ; expr3 ) statement 在 C99 中第一个表达式可以替换为一个声明, 用来声明一个用于循环的变量 for (int i = 0; i < n; i++) 变量 i 不需要在 for 语句之前进行声明如果变量 i 在之前已经进行了声明, 这个语句将创建一个新的 i 且该值仅用于循环内 53

54 C99 中的 for 语句 for 语句声明的变量不可以在循环外访问 ( 在循环外不可见 ) for (int i = 0; i < n; i++) { printf("%d", i); /* legal; i is visible inside loop */ } printf("%d", i); /*** WRONG ***/ 54

55 C99 中的 for 语句 for 语句声明自己的循环控制变量使得程序可读性更强如果在 for 循环退出之后还要使用该变量, 只能使用以前的 for 语句格式 for 语句可以声明多个变量, 只要它们的类型相同 : for (int i = 0, j = 0; i < n; i++) 55

56 C99 中的数组数组初始化式最常见的格式是一个用大括号括起来的逗号分隔的常量表达式 int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 如果初始化式比数组短, 那么数组中剩余的元素初始化为 0 int a[10] = {1, 2, 3, 4, 5, 6}; /* initial value of a is {1, 2, 3, 4, 5, 6, 0, 0, 0, 0} */ 利用这一特性, 可以很容易把数组初始化为全 0 int a[10] = {0}; /* initial value of a is {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} */ 初始化式完全为空是非法的, 所以要在大括号内放上一个 0 初始化式比数组长也是非法的 56

57 C99 中的数组有时数组中只有较少的元素需要显式初始化, 其他元素进行默认初始化 int a[15] = {0, 0, 29, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 48}; 使用指定初始化式可以解决这个问题 int a[15] = {[2] = 29, [9] = 7, [14] = 48}; 括号中的数字称为指示符初始化的顺序不再重要 int a[15] = {[14] = 48, [9] = 7, [2] = 29}; 对多维数组也有效, 例如创建 2x2 的单位阵 double ident[2][2] = {[0][0] = 1.0, [1][1] = 1.0}; 57

58 C99 中的数组指示符必须是整型常量表达式如果待初始化的数组长度是 n, 指示符的值必须在 0 和 n-1 之间如果数组的长度是省略的, 指示符可以是任意非负整数编译器根据最大的指示符推断出数组的长度, 下面数组有 24 个元素 int b[] = {[5] = 10, [23] = 13, [11] = 36, [15] = 29}; 初始化式中可以同时使用旧方法 ( 逐元素初始化 ) 和新方法 ( 指定初始化 ) int c[10] = {5, 1, 9, [4] = 3, 7, 2, [8] = 6}; // int c[10] = {5, 1, 9, 0, 3, 7, 2, 0, 6, 0} 58

59 对数组使用 sizeof sizeof 运算符可以确定数组的大小 ( 字节数 ) 如果数组 a 有 10 个整数, 那么 sizeof(a) 通常为 40 sizeof 可以来计算数组元素 ( 如 a[0]) 大小用数组大小除以数组元素的大小可以得到数组的长度 sizeof(a) / sizeof(a[0]) 59

60 对数组使用 sizeof 对数组 a 清零可以写成如下形式 : for (i = 0; i < sizeof(a) / sizeof(a[0]); i++) a[i] = 0; 使用这种方法, 即使数组长度日后改变, 也不需要改变循环有些编译器会对表达式 i < sizeof(a) / sizeof(a[0]) 给出警告消息, 这是因为 i 可能为 int 型,sizeof 返回类型为无符号的 size_t 型 for (i = 0; i < (int) (sizeof(a) / sizeof(a[0])); i++) a[i] = 0; 60

61 C99 中的变长数组在 C89 中, 数组变量的长度必须用常量表达式进行定义在 C99 中, 有时也可以使用非常量表达式变长数组 (variable-length array, VLA) 的长度在程序运行时计算, 而不是在编译时程序员不必在声明数组时给定一个长度 61

62 C99 中的变长数组 #include <stdio.h> int main(void) { int i, n; printf("how many numbers do you want to reverse? "); scanf("%d", &n); int a[n]; /* C99 only - length of array depends on n */ printf("enter %d numbers: ", n); for (i = 0; i < n; i++) scanf("%d", &a[i]); printf("in reverse order:"); for (i = n - 1; i >= 0; i--) printf(" %d", a[i]); printf("\n"); return 0; } 62

63 C99 中的变长数组变长数组的长度可以是任意整型表达式 ( 可以包含运算符 ) int a[3*i+5]; int b[j+k]; 变长数组也可以是多维数组 : int c[m][n]; 变长数组的限制 : 没有静态存储期没有初始化式 C99 不允许 goto 语句绕过变长数组的声明 POJ 不支持变长数组 (VC2008/GCC4.4.0) 63

64 main 函数一般地,main 函数的返回类型是 int: int main(void) { } 旧式的 C 程序经常省略 main 的返回类型, 假定默认为 int: main() { } 在 C99 中省略 main 的返回类型是非法的在 main 的形参列表中省略 void 仍然是合法的, 但最好加上它 64

65 程序终止 main 函数返回的值是状态码, 在某些操作系统中程序终止时可以检测到状态码返回 0, 程序正常终止返回非 0, 表示异常终止尽量保证每个 C 程序都返回状态码 65

66 exit 函数在 main 函数中执行 return 语句是终止程序的一种方法另一种方法是调用 exit 函数, 该函数属于 <stdlib.h> 传递给 exit 函数的实参与 main 函数的返回值具有相同的含义 : 两者都说明程序终止时的状态为了表示正常终止, 传递 0: exit(0); /* normal termination */ 66

67 exit 函数 exit 函数既然 0 含义有些模糊,C 语言允许使用 EXIT_SUCCESS 来代替 ( 效果是相同的 ): exit(exit_success); 传递 EXIT_FAILURE 表示异常终止 : exit(exit_failure); EXIT_SUCCESS 和 EXIT_FAILURE 是定义在 <stdlib.h> 中的宏 EXIT_SUCCESS 和 EXIT_FAILURE 的值是由实现所定义, 通常分别是 0 和 1 67

68 exit 函数 main 函数中的语句 return expression; 等价于 exit(expression); return 语句和 exit 函数之间的差异 : 不管哪个函数调用 exit 函数都会导致程序终止 return 语句仅当由 main 函数调用时才会导致程序终止 68

69 命令行参数用户在 DOS 窗口输入可执行文件名的方式启动程序时, 跟在可执行文件名后面的那些字符串, 称为命令行参数命令行参数可以有多个, 以空格分隔比如, 在 Dos 窗口敲 : copy file1.txt file2.txt copy, file1.txt, file2.txt 就是命令行参数如何在程序中获得命令行参数呢? 69

70 命令行参数命令行参数 int main(int argc, char * argv[]) { } 参数 argc 就代表启动程序时, 命令行参数的个数 C/C++ 语言规定, 可执行程序程序本身的文件名, 也算一个命令行参数, 因此,argc 的值至少是 1 argv 是一个数组, 其中的每个元素都是一个 char* 类型的指针, 该指针指向一个字符串, 这个字符串里就存放着命令行参数 argv[0] 指向的字符串就是第一个命令行参数, 即可执行程序的文件名,argv[1] 指向第二个命令行参数, argv[2] 指向第三个命令行参数 70

71 例子命令行参数 #include <stdio.h> int main(int argc, char * argv[]) { int i; for(i = 0; i < argc; i ++ ) printf( "%s\n",argv[i]); return 0; } 将上面的程序编译成 sample.exe, 然后在控制台窗口敲 : sample para1 para2 s.txt 5 4 输出结果就是 : sample para1 para2 s.txt

72 C 语言标准库函数数学库函数 math.h 字符处理函数 ctype.h 字符串处理与内存操作函数 string.h 字符串转换函数 stdlib.h 72

73 数学库函数标准库函数数学库函数声明在 math.h 中, 主要有 : abs(x) 求整型数 x 的绝对值 cos(x) x( 弧度 ) 的余弦 fabs(x) 求浮点数 x 的绝对值 ceil(x) 求不小于 x 的最小整数 floor(x) 求不大于 x 的最小整数 log(x) 求 x 的自然对数 log10(x) 求 x 的对数 ( 底为 10) pow(x,y) 求 x 的 y 次方 sin(x) 求 x( 弧度 ) 的正弦 sqrt(x) 求 x 的平方根 73

74 字符处理函数标准库函数在 ctype.h 中声明, 主要有 : int isdigit(int c) 判断 c 是否是数字字符 int isalpha(int c) 判断 c 是否是一个字母 int isalnum(int c) 判断 c 是否是一个数字或字母 int islower(int c) 判断 c 是否是一个小写字母 int isupper(int c) 判断 c 是否是一个大写字母 int toupper(int c) 如果 c 是一个小写字母, 则返回其大写字母 int tolower (int c) 如果 c 是一个大写字母, 则返回其小写字母 74

75 字符串和内存操作函数标准库函数字符串和内存操作函数声明在 string.h 中, 常用的有 : char * strchr(char * s, int c) 如果 s 中包含字符 c, 则返回一个指向 s 第一次出现的该字符的指针, 否则返回 NULL char * strstr(char * s1, char * s2) 如果 s2 是 s1 的一个子串, 则返回一个指向 s1 中首次出现 s2 的位置的指针, 否则返回 NULL char * strlwr(char * s) 将 s 中的字母都变成小写 char * strupr( char * s) 将 s 中的字母都变成大写 char * strcpy( char * s1, char * s2) 将字符串 s2 的内容拷贝到 s1 中去 char * strncpy( char * s1, char * s2,int n) 将字符串 s2 的内容拷贝到 s1 中去, 但是最多拷贝 n 个字节如果拷贝字节数达到 n, 那么就不会往 s1 中写入结尾的 \0 75

76 字符串和内存操作函数标准库函数 char * strcat( char * s1, char * s2) 将字符串 s2 添加到 s1 末尾 int strcmp( char * s1, char * s2) 比较两个字符串, 大小写相关如果返回值小于 0, 则说明 s1 按字典顺序在 s2 前面 ; 返回值等于 0, 则说明两个字符串一样 ; 返回值大于 0, 则说明 s1 按字典顺序在 s2 后面 int stricmp( char * s1, char * s2) 比较两个字符串, 大小写无关其他和 strcmp 同 int strlen(const char * string) 计算字符串的长度 void * memcpy( void * s1, void * s2, int n) 将内存地址 s2 处的 n 字节内容拷贝到内存地址 s1 void * memset( void * s, int c, int n) 将内存地址 s 开始的 n 个字节全部置为 c 76

77 字符串转换函数标准库函数有几个函数, 可以完成将字符串转换为整数, 或将整数转换成字符串等这类功能它们定义在 stdlib.h 中 : int atoi(char *s) 将字符串 s 里的内容转换成一个整型数返回比如, 如果字符串 s 的内容是 "1234", 那么函数返回值就是 1234 double atof(char *s) 将字符串 s 中的内容转换成浮点数 77

78 字符串转换函数标准库函数 char *itoa(int value, char *string, int radix); 将整型值 value 以 radix 进制表示法写入 string 比如 : char szvalue[20]; itoa( 32, szvalue, 10); 则使得 szvalue 的内容变为 32 itoa( 32, szvalue, 16); 则使得 szvalue 的内容变为 20 78

79 动态内存分配 C 语言的数据结构, 例如数组, 通常是固定大小的因为在写程序时强制选择了大小, 所以固定大小的数据结构可能会有问题 C 语言支持动态内存分配 (dynamic storage allocation): 在程序执行期间分配内存的能力利用动态内存分配, 可以设计根据需要扩大 ( 和缩小 ) 的数据结构 79

80 动态内存分配动态内存分配主要用于字符串数组和结构体动态分配的结构体可以链接形成链表树或其他数据结构为了动态分配内存, 需要调用内存分配函数 80

81 内存分配函数动态内存分配 <stdlib.h> 头文件声明了三个内存分配函数 : malloc 分配内存块, 但不进行初始化 calloc 分配内存块, 并对内存块进行清零 realloc 调整先前分配的内存块大小这些函数返回 void *( 通用指针 ) 类型的值 81

82 空指针动态内存分配如果内存分配函数无法分配所需大小的内存块, 函数会返回空指针空指针是能区别于所有有效指针的特殊值在把函数返回值存储到指针变量后, 需要检查该指针变量是否为空指针 82

83 空指针动态内存分配测试 malloc 函数返回值的例子 : p = malloc(10000); if (p == NULL) { /* allocation failed; take appropriate action */ } NULL 是一个宏, 表示空指针一些程序员把 malloc 函数的调用和 NULL 的测试组合在一起 : if ((p = malloc(10000)) == NULL) { /* allocation failed; take appropriate action */ } 83

84 空指针动态内存分配指针测试真假的方法和数的测试一样 : 所有非空指针都为真, 而只有空指针为假语句 if (p == NULL) 可以写成 if (!p) 而语句 if (p!= NULL) 则可以写成 if (p) 84

85 动态分配字符串动态内存分配动态内存分配对字符串操作非常有用字符串存储在字符数组中, 而且可能很难预测这些数组需要的长度通过动态分配字符串, 可以推迟到程序运行时才作决定 85

86 用 malloc 为字符串分配内存动态内存分配 malloc 函数具有如下原型 : void *malloc(size_t size); malloc 函数分配 size 个字节的内存块, 并返回指向该内存块的指针 size_t 是在 C 库中定义的无符号整数类型 86

87 用 malloc 为字符串分配内存动态内存分配为给 n 个字符的字符串分配内存空间, 可以写成 : p = malloc(n + 1); 这里,p 是一个 char * 类型变量每个字符需要一个字节的内存,n+1 给空字符留了空间一些程序员喜欢对 malloc 函数的返回值进行强制类型转换, 但这个转换不是必需的 : p = (char *) malloc(n + 1); 87

88 用 malloc 为字符串分配内存动态内存分配使用 malloc 函数分配的内存不会清零, 所以 p 指向有 n+1 个字符的未初始化数组 : 88

89 用 malloc 为字符串内存分配动态内存分配对该数组进行初始化的一种方法是调用 strcpy 函数 : strcpy(p, "abc"); 数组中的前 4 个字符分别是 a, b, c, 和 \0: 89

90 在字符串函数中使用动态内存分配动态内存分配动态内存分配使编写返回指向新字符串的指针的函数成为可能考虑编写函数把两个字符串连接起来而不改变其中任何一个字符串度量待连接的两个字符串的长度, 然后调用 malloc 函数为结果分配适当大小的内存空间把第一个字符串复制到新的内存空间中调用 strcat 函数来拼接第二个字符串 90

91 在字符串函数中使用动态内存分配动态内存分配 char *concat(const char *s1, const char *s2) { char *result; } result = malloc(strlen(s1) + strlen(s2) + 1); if (result == NULL) { printf("error: malloc failed in concat\n"); exit(exit_failure); } strcpy(result, s1); strcat(result, s2); return result; 91

92 在字符串函数中使用动态内存分配动态内存分配 concat 函数可能的调用方式 : p = concat("abc", "def"); 调用后,p 将指向字符串 abcdef, 此字符串存储在动态分配数组中像 concat 这样的动态分配内存的函数必须小心使用当不在需要 concat 函数返回的字符串是, 需要调用 free 函数来释放它占用的空间如果不这样做, 程序最终会耗光内存 92

93 动态分配数组动态内存分配动态分配数组有和动态分配字符串相同的好处数组和指针间的紧密联系是的动态分配数组用起来像普通数组一样简单尽管 malloc 函数可以为数组分配内存空间, 但有时会用 calloc 函数代替, 因为 calloc 函数会初始化分配的内存 realloc 函数允许根据需要对数组进行扩展或缩减 93

94 用 malloc 为数组分配内存动态内存分配假定程序需要一个由 n 个整数构成的数组, 这里 n 可以在程序运行时计算出来首先声明指针变量 : int *a; 一旦 n 的值已知了, 程序调用 malloc 函数为数组分配存储空间 : a = malloc(n * sizeof(int)); 始终使用 sizeof 运算符来计算每个数组元素所需的空间大小 94

95 用 malloc 为数组分配内存动态内存分配可以忽略 a 是指针的事实, 把它当作数组名来使用例如, 可以使用下列循环对 a 指向的数组进行初始化 : for (i = 0; i < n; i++) a[i] = 0; 当然用指针算术运算代替下标操作来访问数组元素也是可行的 95

96 calloc 函数动态内存分配 calloc 函数也可以用来为数组分配内存 calloc 函数的原型为 : void *calloc(size_t nmemb, size_t size); calloc 函数的性质 : 为 nmemb 个元素的数组分配内存, 每个元素有 size 个字节长如果请求的空间不足, 返回空指针通过把所有位设置为 0 的方式进行初始化 96

97 calloc 函数动态内存分配下列 calloc 函数调用为 n 个整数的数组分配存储空间 : a = calloc(n, sizeof(int)); 通过调用以 1 为第一个实参的 calloc 函数, 可以为任何类型的数据项来分配空间 : struct point { int x, y; } *p; p = calloc(1, sizeof(struct point)); 97

98 realloc 函数动态内存分配 realloc 函数可以调整动态分配数组的大小 realloc 函数的原型为 : void *realloc(void *ptr, size_t size); ptr 必须指向先前通过调用 malloc calloc 或 realloc 函数获得的内存块 size 表示内存块的新尺寸, 新尺寸可能大于或小于原有尺寸 98

99 realloc 函数动态内存分配 realloc 函数的性质 : 当扩展内存块时,realloc 函数不会对添加进内存块的字节进行初始化如果 recalloc 函数不能按要求扩大内存块, 那么返回空指针, 且原有内存块中数据不变如果 realloc 函数被调用时, 以空指针作为第一个实参, 则行为类似于 malloc 函数如果 realloc 函数被调用时, 以 0 作为第二个实参, 那么它会释放掉内存块 99

100 realloc 函数动态内存分配希望 realloc 函数非常高效 : 在要求减小内存块大小时,realloc 函数应该在原先的内存块上就地进行缩减同理, 扩大内存块时也不应该对其进行移动如果无法就地扩大内存块,realloc 函数会在别处分配新的内存块, 然后把旧块中内容复制到新块中一旦 realloc 函数返回, 一定要对指向内存块的所有指针进行更新, 因为内存块可能被移动了 100

101 释放内存动态内存分配 malloc 和其他内存分配函数所获得的内存块来自一个称为堆 (heap) 的存储池过于频繁地调用这些函数 ( 或让这些函数申请大内存块 ) 可能会耗尽堆, 导致这些函数返回空指针更糟的是, 程序可能分配了内存块, 然后又丢失了对这些块的记录, 从而浪费了空间 101

102 释放内存动态内存分配例如 : p = malloc( ); q = malloc( ); p = q; 在执行完前两条语句后,p 和 q 分别指向一个内存块 : 102

103 释放内存动态内存分配在把 q 赋值给 p 后, 两个指针都指向了第二个内存块 : 没有指针指向第一个内存块, 因此再也不能使用此内存块了 103

104 释放内存动态内存分配对程序而言, 不可再访问到的内存块被称为垃圾 (garbage) 留有垃圾的程序存在内存泄漏 (memory leak) 一些语言提供垃圾收集器, 用于垃圾的自动定位和回收, 但 C 语言不提供相反, 每个 C 程序负责回收各自的垃圾, 方法是调用 free 函数来释放不需要的内存 104

105 free 函数动态内存分配 free 函数在 <stdlib.h> 中有如下原型 : void free(void *ptr); 把指向不再需要的内存块的指针传递给 free 函数 : p = malloc( ); q = malloc( ); free(p); p = q; 调用 free 函数会释放 p 所指向的内存块 105

106 悬空指针问题动态内存分配使用 free 函数会导致一个新问题 : 悬空指针 (dangling pointer) free(p) 释放 p 指向的内存块, 但不会改变 p 自身如果忘记了 p 不再指向有效内存块, 可能导致问题 : char *p = malloc(4); free(p); strcpy(p, "abc"); /*** WRONG ***/ 修改 p 指向的内存可能导致严重的错误 106

107 悬空指针问题动态内存分配一种解决方案 :free 后, 把指针置为空 free(p); p = NULL; 悬空指针有时很难被发现, 因为几个指针可能指向相同的内存块在释放内存块后, 所有的指针都悬空了 107

108 编程题 3718: 给定两个 unsigned short 类型整数, 判断一个是否能由另一个经过循环左移若干位得到 3719: 将输入的学生信息按姓名排序后输出 2677: 肿瘤检测 109

CC213

CC213 : (Ken-Yi Lee), E-mail: feis.tw@gmail.com 49 [P.51] C/C++ [P.52] [P.53] [P.55] (int) [P.57] (float/double) [P.58] printf scanf [P.59] [P.61] ( / ) [P.62] (char) [P.65] : +-*/% [P.67] : = [P.68] : ,