幻灯片 1

Transcription

1 信息科学技术学院 程序设计实习 郭炜微博 刘家瑛微博 1

2 信息科学技术学院 程序设计实习 郭炜刘家瑛 函数指针 ( 教材 P107) 2

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

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

5 定义形式 类型名 (* 指针变量名 )( 参数类型 1, 参数类型 2, ); 5

6 定义形式 类型名 (* 指针变量名 )( 参数类型 1, 参数类型 2, ); 例如 : int (*pf)(int,char); 6

7 定义形式 类型名 (* 指针变量名 )( 参数类型 1, 参数类型 2, ); 例如 : int (*pf)(int,char); 表示 pf 是一个函数指针, 它所指向的函数, 返回值类型应是 int, 该函数应有两个参数, 第一个是 int 类型, 第二个是 char 类型 7

8 使用方法 可以用一个原型匹配的函数的名字给一个函数指针赋值 要通过函数指针调用它所指向的函数, 写法为 : 函数指针名 ( 实参表 ); 8

9 使用方法 #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; } 9

10 使用方法 #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; PrintMin } 10 pf

11 使用方法 #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 PrintMin } 11 pf

12 函数指针和 qsort 库函数 C 语言快速排序库函数 : void qsort(void *base, int nelem, unsigned int width, int ( * pfcompare)( const void *, const void *)); 可以对任意类型的数组进行排序 12

13 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] 对数组排序, 需要知道 : 13

14 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] 对数组排序, 需要知道 : 1) 数组起始地址 14

15 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] 对数组排序, 需要知道 : 1) 数组起始地址 2) 数组元素的个数 15

16 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] 对数组排序, 需要知道 : 1) 数组起始地址 2) 数组元素的个数 3) 每个元素的大小 ( 由此可以算出每个元素的地址 ) 16

17 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] 对数组排序, 需要知道 : 1) 数组起始地址 2) 数组元素的个数 3) 每个元素的大小 ( 由此可以算出每个元素的地址 ) 4) 元素谁在前谁在后的规则 17

18 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] void qsort(void *base, int nelem, unsigned int width, int ( * pfcompare)( const void *, const void *)); base: 待排序数组的起始地址, 18

19 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] void qsort(void *base, int nelem, unsigned int width, int ( * pfcompare)( const void *, const void *)); base: 待排序数组的起始地址, nelem: 待排序数组的元素个数, 19

20 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] void qsort(void *base, int nelem, unsigned int width, int ( * pfcompare)( const void *, const void *)); base: 待排序数组的起始地址, nelem: 待排序数组的元素个数, width: 待排序数组的每个元素的大小 ( 以字节为单位 ) 20

21 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] void qsort(void *base, int nelem, unsigned int width, int ( * pfcompare)( const void *, const void *)); base: 待排序数组的起始地址, nelem: 待排序数组的元素个数, width: 待排序数组的每个元素的大小 ( 以字节为单位 ) pfcompare : 比较函数的地址 21

22 函数指针和 qsort 库函数 void qsort(void *base, int nelem, unsigned int width, int ( * pfcompare)( const void *, const void *)); pfcompare: 函数指针, 它指向一个 比较函数 该比较函数应为以下形式 : int 函数名 (const void * elem1, const void * elem2); 比较函数是程序员自己编写的 22

23 函数指针和 qsort 库函数 排序就是一个不断比较并交换位置的过程 qsort 函数在执行期间, 会通过 pfcompare 指针调用 比较函数, 调用时将要比较的两个元素的地址传给 比较函数, 然后根据 比较函数 返回值判断两个元素哪个更应该排在前面 23

24 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] pfcompare( e1, e2 );

25 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] pfcompare( e1, e2 ); int 比较函数名 (const void * elem1, const void * elem2); 25

26 函数指针和 qsort 库函数 a[0] a[1] a[i] a[n-1] pfcompare( e1, e2 ); int 比较函数名 (const void * elem1, const void * elem2); 比较函数编写规则 : 1) 如果 * elem1 应该排在 * elem2 前面, 则函数返回值是负整数 2) 如果 * elem1 和 * elem2 哪个排在前面都行, 那么函数返回 0 3) 如果 * elem1 应该排在 * elem2 后面, 则函数返回值是正整数 26

27 函数指针和 qsort 库函数 实例 : 下面的程序, 功能是调用 qsort 库函数, 将一个 unsigned int 数组按照个位数从小到大进行排序 比如 8,23,15 三个数, 按个位数从小到大排序, 就应该是 23,15,8 27

28 #include <stdio.h> #include <stdlib.h> int MyCompare( const void * elem1, const void * elem2 ) { unsigned int * p1, * p2; p1 = (unsigned int *) elem1; // * elem1 非法 p2 = (unsigned int *) elem2; // * elem2 非法 return (* p1 % 10) - (* p2 % 10 ); } #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; } 输出结果 :

29 信息科学技术学院 程序设计实习 郭炜微博 刘家瑛微博 1

30 信息科学技术学院 程序设计实习 郭炜刘家瑛 命令行参数 ( 教材 P157) 2

31 命令行方式运行程序 Windows + R 键 : 3

32 命令行方式运行程序 4

33 命令行方式运行程序 5

34 命令行方式运行程序 notepad sample.txt notepad 程序如何得知, 用户在以命令行方式运行它的时候, 后面跟着什么参数? 6

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

36 命令行参数 int main(int argc, char * argv[]) { } argc: 代表启动程序时, 命令行参数的个数 C/C++ 语言规定, 可执行程序程序本身的文件名, 也算一个命令行参数, 因此,argc 的值至少是 1 8

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

38 #include <stdio.h> int main(int argc, char * argv[]) { for(int i = 0;i < argc; i ++ ) printf( "%s\n",argv[i]); return 0; } 将上面的程序编译成 sample.exe, 然后在控制台窗口敲 : sample para1 para2 s.txt 5 hello world

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

40 信息科学技术学院 程序设计实习 郭炜微博 刘家瑛微博 1

41 信息科学技术学院 程序设计实习 郭炜刘家瑛 位运算 ( 教材 P28) 2

42 基本概念 位运算 : 用于对整数类型 (int,char, long 等 ) 变量中的某一位 (bit), 或者若干位进行操作 比如 : 3

43 基本概念 位运算 : 用于对整数类型 (int,char, long 等 ) 变量中的某一位 (bit), 或者若干位进行操作 比如 : 1) 判断某一位是否为 1 4

44 基本概念 位运算 : 用于对整数类型 (int,char, long 等 ) 变量中的某一位 (bit), 或者若干位进行操作 比如 : 1) 判断某一位是否为 1 2) 只改变其中某一位, 而保持其他位都不变 5

45 基本概念 位运算 : 用于对整数类型 (int,char, long 等 ) 变量中的某一位 (bit), 或者若干位进行操作 比如 : 1) 判断某一位是否为 1 2) 只改变其中某一位, 而保持其他位都不变 C/C++ 语言提供了六种位运算符来进行位运算操作 : & 按位与 ( 双目 ) 按位或 ( 双目 ) ^ 按位异或 ( 双目 ) ~ 按位非 ( 取反 )( 单目 ) << 左移 ( 双目 ) >> 右移 ( 双目 ) 6

46 按位与 & 将参与运算的两操作数各对应的二进制位进行与操作, 只有对应的两个二进位均为 1 时, 结果的对应二进制位才为 1, 否则为 0 7

47 按位与 & 例如 : 表达式 21 & 18 的计算结果是 16 ( 即二进制数 10000), 因为 : 8

48 按位与 & 例如 : 表达式 21 & 18 的计算结果是 16 ( 即二进制数 10000), 因为 : 21 用二进制表示就是 : 用二进制表示就是 : 二者按位与所得结果是 :

49 按位与 & 通常用来将某变量中的某些位清 0 且同时保留其他位不变 也可以用来获取某变量中的某一位 例如, 如果需要将 int 型变量 n 的低 8 位全置成 0, 而其余位不变, 则可以执行 : 10

50 按位与 & 通常用来将某变量中的某些位清 0 且同时保留其他位不变 也可以用来获取某变量中的某一位 例如, 如果需要将 int 型变量 n 的低 8 位全置成 0, 而其余位不变, 则可以执行 : n = n & 0xffffff00; 11

51 按位与 & 通常用来将某变量中的某些位清 0 且同时保留其他位不变 也可以用来获取某变量中的某一位 例如, 如果需要将 int 型变量 n 的低 8 位全置成 0, 而其余位不变, 则可以执行 : n = n & 0xffffff00; 也可以写成 : n &= 0xffffff00; 12

52 按位与 & 通常用来将某变量中的某些位清 0 且同时保留其他位不变 也可以用来获取某变量中的某一位 例如, 如果需要将 int 型变量 n 的低 8 位全置成 0, 而其余位不变, 则可以执行 : n = n & 0xffffff00; 也可以写成 : n &= 0xffffff00; 如果 n 是 short 类型的, 则只需执行 : n &= 0xff00; 13

53 按位与 & 如何判断一个 int 型变量 n 的第 7 位 ( 从右往左, 从 0 开始数 ) 是否是 1? 14

54 按位与 & 如何判断一个 int 型变量 n 的第 7 位 ( 从右往左, 从 0 开始数 ) 是否是 1? 只需看表达式 n & 0x80 的值是否等于 0x80 即可 0x80:

55 按位或 将参与运算的两操作数各对应的二进制位进行或操作, 只有对应的两个二进位都为 0 时, 结果的对应二进制位才是 0, 否则为 1 16

56 按位或 例如 : 表达式 的值是 23, 因为 : 17

57 按位或 例如 : 表达式 的值是 23, 因为 : 21: : :

58 按位或 按位或运算通常用来将某变量中的某些位置 1 且保留其他位不变 例如, 如果需要将 int 型变量 n 的低 8 位全置成 1, 而其余位不变, 则可以执行 : 19

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

60 按位异或 ^ 将参与运算的两操作数各对应的二进制位进行异或操作, 即只有对应的两个二进位不相同时, 结果的对应二进制位才是 1, 否则为 0 例如 : 表达式 21 ^ 18 的值是 7( 即二进制数 111) 21: : ^18:

61 按位异或 ^ 按位异或运算通常用来将某变量中的某些位取反, 且保留其他位不变 例如, 如果需要将 int 型变量 n 的低 8 位取反, 而其余位不变, 则可以执行 : n ^= 0xff; 0xff:

62 按位异或 ^ 异或运算的特点是 : 如果 a^b=c, 那么就有 c^b = a 以及 c^a=b ( 穷举法可证 ) 此规律可以用来进行最简单的加密和解密 23

63 按位异或 ^ 另外异或运算还能实现不通过临时变量, 就能交换两个变量的值 : int a = 5, b = 7; a = a ^ b; b = b ^ a; a = a ^ b; 即实现 a,b 值交换 穷举法可证 24

64 按位非 ~ 按位非运算符 ~ 是单目运算符 其功能是将操作数中的二进制位 0 变成 1,1 变成 0 例如, 表达式 ~21 的值是整型数 0xffffffea 21: ~21:

65 左移运算符 << 表达式 : a << b 的值是 : 将 a 各二进位全部左移 b 位后得到的值 左移时, 高位丢弃, 低位补 0 a 的值不因运算而改变 26

66 左移运算符 << 例如 : 9 << 4 9 的二进制形式 : 因此, 表达式 9<<4 的值, 就是将上面的二进制数左移 4 位, 得 : 即为十进制的

67 左移运算符 << 实际上, 左移 1 位, 就等于是乘以 2, 左移 n 位, 就等于是乘以 2 n 而左移操作比乘法操作快得多 28

68 右移运算符 >> 表达式 : a >> b 的值是 : 将 a 各二进位全部右移 b 位后得到的值 右移时, 移出最右边的位就被丢弃 a 的值不因运算而改变 29

69 右移运算符 >> 表达式 : a >> b 的值是 : 将 a 各二进位全部右移 b 位后得到的值 右移时, 移出最右边的位就被丢弃 a 的值不因运算而改变 对于有符号数, 如 long,int,short,char 类型变量, 在右移时, 符号位 ( 即最高位 ) 将一起移动, 并且大多数 C/C++ 编译器规定, 如果原符号位为 1, 则右移时高位就补充 1, 原符号位为 0, 则右移时高位就补充 0 30

70 右移运算符 >> 实际上, 右移 n 位, 就相当于左操作数除以 2 n, 并且将结果往小里取整 -25 >> 4 = -2-2 >> 4 = >> 4 = 1 31

71 #include <stdio.h> int main() { int n1 = 15; short n2 = -15; unsigned short n3 = 0xffe0; char c = 15; n1 = n1>>2; n2 >>= 3; n3 >>= 4; c >>= 3; printf( "n1=%d,n2=%x,n3=%x,c=%x",n1,n2,n3,c); } 32

72 #include <stdio.h> int main() { int n1 = 15; short n2 = -15; unsigned short n3 = 0xffe0; char c = 15; n1 = n1>>2; n2 >>= 3; n3 >>= 4; c >>= 3; printf( "n1=%d,n2=%x,n3=%x,c=%x",n1,n2,n3,c); } // 输出结果是 :n1=3,n2=fffffffe,n3=ffe,c=1 33

73 n1: n1 >>= 2: 变成 n2: n2 >>= 3: 变成 fffffffe, 即 n3: n3 >>= 4: 变成 ffe c: c >>= 3; 变成 int n1 = 15; short n2 = -15; unsigned short n3 = 0xffe0; char c = 15; 34

74 思考题 : 有两个 int 型的变量 a 和 n(0 <= n <= 31), 要求写一个表达式, 使该表达式的值和 a 的第 n 位相同 35

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

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

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

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

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

80 信息科学技术学院 程序设计实习 郭炜 刘家瑛 引用 的概念和应用 1

81 引用的概念 ( 教材第 62 页 ) 下面的写法定义了一个引用, 并将其初始化为引用某个变量 类型名 & 引用名 = 某变量名 ; int n = 4; int & r = n; // r 引用了 n, r 的类型是 2

82 引用的概念 ( 教材第 62 页 ) 下面的写法定义了一个引用, 并将其初始化为引用某个变量 类型名 & 引用名 = 某变量名 ; int n = 4; int & r = n; // r 引用了 n, r 的类型是 int & 3

83 引用的概念 ( 教材第 62 页 ) 下面的写法定义了一个引用, 并将其初始化为引用某个变量 类型名 & 引用名 = 某变量名 ; int n = 4; int & r = n; // r 引用了 n, r 的类型是 int & 某个变量的引用, 等价于这个变量, 相当于该变量的一个别名 4

84 引用的概念 int n = 4; int & r = n; r = 4; cout << r; // 输出 4 cout << n; n = 5; cout << r; 5

85 引用的概念 int n = 4; int & r = n; r = 4; cout << r; // 输出 4 cout << n; // 输出 4 n = 5; cout << r; 6

86 引用的概念 int n = 4; int & r = n; r = 4; cout << r; // 输出 4 cout << n; // 输出 4 n = 5; cout << r; // 输出 5 7

87 引用的概念 定义引用时一定要将其初始化成引用某个变量 8

88 引用的概念 定义引用时一定要将其初始化成引用某个变量 初始化后, 它就一直引用该变量, 不会再引用别的变量了 9

89 引用的概念 定义引用时一定要将其初始化成引用某个变量 初始化后, 它就一直引用该变量, 不会再引用别的变量了 引用只能引用变量, 不能引用常量和表达式 10

90 引用的概念 double a = 4, b = 5; double & r1 = a; double & r2 = r1; // r2 也引用 a r2 = 10; cout << a << endl; r1 = b; cout << a << endl; 11

91 引用的概念 double a = 4, b = 5; double & r1 = a; double & r2 = r1; // r2 也引用 a r2 = 10; cout << a << endl; // 输出 10 r1 = b; cout << a << endl; 12

92 引用的概念 double a = 4, b = 5; double & r1 = a; double & r2 = r1; // r2 也引用 a r2 = 10; cout << a << endl; // 输出 10 r1 = b; // r1 并没有引用 b cout << a << endl; 13

93 引用的概念 double a = 4, b = 5; double & r1 = a; double & r2 = r1; // r2 也引用 a r2 = 10; cout << a << endl; // 输出 10 r1 = b; // r1 并没有引用 b cout << a << endl; // 输出 5 14

94 引用应用的简单示例 C 语言中, 如何编写交换两个整型变量值的函数? 15

95 引用应用的简单示例 C 语言中, 如何编写交换两个整型变量值的函数? void swap( int * a, int * b) { int tmp; tmp = * a; * a = * b; * b = tmp; } int n1, n2; swap(& n1,& n2) ; // n1,n2 的值被交换 16

96 引用应用的简单示例 有了 C++ 的引用 : void swap( int & a, int & b) { int tmp; tmp = a; a = b; b = tmp; } int n1, n2; swap(n1,n2) ; // n1,n2 的值被交换 17

97 引用作为函数的返回值 ( 教材第 63 页 ) int n = 4; int & SetValue() { return n; } int main() { SetValue() = 40; cout << n; return 0; } 18

98 引用作为函数的返回值 ( 教材第 63 页 ) int n = 4; int & SetValue() { return n; } int main() { SetValue() = 40; cout << n; return 0; } // 输出 : 40 19

99 常引用 ( 教材第 65 页 ) 定义引用时, 前面加 const 关键字, 即为 常引用 int n; const int & r = n; r 的类型是 20

100 常引用 ( 教材第 65 页 ) 定义引用时, 前面加 const 关键字, 即为 常引用 int n; const int & r = n; r 的类型是 const int & 21

101 常引用 不能通过常引用去修改其引用的内容 : int n = 100; const int & r = n; r = 200; // 编译错 n = 300; // 没问题 22

102 常引用和非常引用的转换 const T & 和 T & 是不同的类型!!! T & 类型的引用或 T 类型的变量可以用来初始化 const T & 类型的引用 const T 类型的常变量和 const T & 类型的引用则不能用来初始化 T & 类型的引用, 除非进行强制类型转换 23

103 QUIZ 1 下面程序片段哪个没错? A) int n = 4; int & r = n * 5; B) int n = 6; const int & r = n; r = 7; C) int n = 8; const int & r1 = n; int & r2 = r1; D) int n = 8; int & r1 = n; const int r2 = r1; 24

104 QUIZ 2 下面程序片段输出结果是什么? int a = 1,b = 2; int & r = a; r = b; r = 7; cout << a << endl; A) 1 B) 2 C) 7 25

105 信息科学技术学院 程序设计实习 郭炜 刘家瑛 下一小节 : const 的用法 26

106 信息科学技术学院 程序设计实习 郭炜 刘家瑛 const 关键字的用法 1

107 1) 定义常量 const int MAX_VAL = 23; const string SCHOOL_NAME = Peking University ; 2

108 2) 定义常量指针 不可通过常量指针修改其指向的内容 int n,m; const int * p = & n; * p = 5; n = 4; p = &m; 3

109 2) 定义常量指针 不可通过常量指针修改其指向的内容 int n,m; const int * p = & n; * p = 5; // 编译出错 n = 4; p = &m; 4

110 2) 定义常量指针 不可通过常量指针修改其指向的内容 int n,m; const int * p = & n; * p = 5; // 编译出错 n = 4; //ok p = &m; 5

111 2) 定义常量指针 不可通过常量指针修改其指向的内容 int n,m; const int * p = & n; * p = 5; // 编译出错 n = 4; //ok p = &m; //ok, 常量指针的指向可以变化 6

112 2) 定义常量指针 不能把常量指针赋值给非常量指针, 反过来可以 const int * p1; int * p2; p1 = p2; //ok p2 = p1; //error p2 = (int * ) p1; //ok, 强制类型转换 7

113 2) 定义常量指针 函数参数为常量指针时, 可避免函数内部不小心改变参数指针所指地方的内容 void MyPrintf( const char * p ) { strcpy( p,"this"); // 编译出错 printf("%s",p); //ok } 8

114 3) 定义常引用 不能通过常引用修改其引用的变量 int n; const int & r = n; r = 5; //error n = 4; //ok 9

115 信息科学技术学院 程序设计实习 郭炜 刘家瑛 下一小节 : 动态内存分配 10

116 信息科学技术学院 程序设计实习 郭炜 刘家瑛 动态内存分配 1

117 用 new 运算符实现动态内存分配 ( 教材 P109) 第一种用法, 分配一个变量 : P = new T; T 是任意类型名,P 是类型为 T * 的指针 动态分配出一片大小为 sizeof(t) 字节的内存空间, 并且将该内存空间的起始地址赋值给 P 比如 : int * pn; pn = new int; * pn = 5; 2

118 用 new 运算符实现动态内存分配 ( 教材 P109) 第二种用法, 分配一个数组 : P = new T[N]; T : 任意类型名 P : 类型为 T * 的指针 N : 要分配的数组元素的个数, 可以是整型表达式 动态分配出一片大小为 sizeof(t) 字节的内存空间, 并且将该内存空间的起始地址赋值给 P 3

119 用 new 运算符实现动态内存分配 ( 教材 P109) 动态分配数组示例 : int * pn; int i = 5; pn = new int[i * 20]; pn[0] = 20; pn[100] = 30; // 编译没问题 运行时导致数组越界 4

120 用 delete 运算符释放动态分配的内存 用 new 动态分配的内存空间, 一定要用 delete 运算符进行释放 delete 指针 ;// 该指针必须指向 new 出来的空间 int * p = new int; * p = 5; delete p; delete p; // 导致异常, 一片空间不能被 delete 多次 5

121 用 delete 运算符释放动态分配的数组 用 delete 释放动态分配的数组, 要加 [] delete [ ] 指针 ;// 该指针必须指向 new 出来的数组 int * p = new int[20]; p[0] = 1; delete [ ] p; 6

122 信息科学技术学院 程序设计实习 郭炜 刘家瑛 下一小节 : 内联函数 函数重载和函数缺省参数 7

123 信息科学技术学院 程序设计实习 郭炜 刘家瑛 内联函数 函数重载 函数缺省参数 1

124 内联函数 ( 教材 P66) 函数调用是有时间开销的 如果函数本身只有几条语句, 执行非常快, 而且函数被反复执行很多次, 相比之下调用函数所产生的这个开销就会显得比较大 为了减少函数调用的开销, 引入了内联函数机制 编译器处理对内联函数的调用语句时, 是将整个函数的代码插入到调用语句处, 而不会产生调用函数的语句 2

125 内联函数 ( 教材 P66) inline int Max(int a,int b) { if( a > b) return a; return b; } 3

126 函数重载 ( 教材 P67) 一个或多个函数, 名字相同, 然而参数个数或参数类型不相同, 这叫做函数的重载 以下三个函数是重载关系 : int Max(double f1,double f2) { } int Max(int n1,int n2) { } int Max(int n1,int n2,int n3) { } 函数重载使得函数命名变得简单 编译器根据调用语句的中的实参的个数和类型判断应该调用哪个函数 4

127 函数重载 ( 教材 P67) (1) int Max(double f1,double f2) { } (2) int Max(int n1,int n2) { } (3) int Max(int n1,int n2,int n3) { } Max(3.4,2.5); // 调用 (1) Max(2,4); // 调用 (2) Max(1,2,3); // 调用 (3) Max(3,2.4); //error, 二义性 5

128 函数的缺省参数 ( 教材 P61): C++ 中, 定义函数的时候可以让最右边的连续若干个参数有缺省值, 那么调用函数的时候, 若相应位置不写参数, 参数就是缺省值 void func( int x1, int x2 = 2, int x3 = 3) { } func(10 ) ; // 等效于 func(10,2,3) func(10,8) ; // 等效于 func(10,8,3) func(10,, 8) ; // 不行, 只能最右边的连续若干个参数缺省 6

129 函数的缺省参数 ( 教材 P61): 函数参数可缺省的目的在于提高程序的可扩充性 即如果某个写好的函数要添加新的参数, 而原先那些调用该函数的语句, 未必需要使用新增的参数, 那么为了避免对原先那些函数调用语句的修改, 就可以使用缺省参数 7

130 浅谈 面向对象程序设计方法 郭炜刘家瑛 北京大学程序设计实习

131 结构化程序设计的思考 结构化程序设计 复杂的大问题 层层分解 / 模块化 若干子问题 自顶向下, 逐步求精 程序 数据变量结构 函数算法 2

132 结构化程序设计的问题 在结构化程序设计中 数据结构 算法 3

133 结构化程序设计的问题 在结构化程序设计中 数据结构 算法 没有直观的联系 4

134 结构化程序设计的程序模式 变量 : var1 var2 var3 Main() 函数 : Sub1() Sub2() Sub3() Sub1_1() Sub3_1() Sub3_2() 5

135 结构化程序设计的问题 不得不面对的四大囧境 : 理解难修改难差错难重用难 6

136 业界需要面向对象 软件设计的目标 : 更快 更正确 更经济 7

137 面向对象的程序设计 面向对象的程序设计方法 面向对象的程序 = 类 + 类 + + 类 设计程序的过程 设计类的过程 8

138 面向对象的程序设计 面向对象的程序设计方法 : 一类事物 抽象 共同属性 数据结构行为 函数 封装 类 class Data Function 9

139 面向对象的程序模式 Main() var1 class1 Sub1() Sub1_1() var2 class2 Sub2() var3 class3 Sub3() Sub3_1() Sub3_2() 10

140 面向对象的程序设计 如果你是 Gru, 面对如此千姿百态的 Minion, 怎么办? 11

141 面向对象的程序设计 class Minion Name; Hair Color; Eye Number; Clothes Type; Minion 类 GetMinionName(); CountEyeNum(); SetHairColor(); SelectClothType(); 12

142 面向对象的程序设计 不同的 Minion 对象 Minion 类 class Minion Name; Hair Color; Eye Number; Clothes Type; GetMinionName(); CountEyeNum(); SetHairColor(); SelectClothType(); 13

143 类的定义 class 类名 { 访问范围说明符 : 成员变量 1 成员变量 2 成员函数声明 1 成员函数声明 2 访问范围说明符 : 更多成员变量更多成员函数声明 }; 14

144 15

145 面向对象程序设计 语言的发展历程 郭炜刘家瑛 北京大学程序设计实习

146 早期程序设计语言的历史 C 语言发展历程 面向对象程序设计语言的发展历程 1960 年, 算法描述语言 ALGOL 60 诞生 (C 语言的原型 ) 1967 年, 剑桥大学的 Martin Richards 对 CPL 语言进行了简化, 产生了 BCPL 语言 1970 年, 美国 Bell Labs 的 Ken Thompson 将 BCPL 进行了修改, 命名为 B 语言 1973 年, AT&T 的 Dennis Ritchie 设计出了一种新的语言, C 语言 1995 年, Sun 公司发布 JAVA 语言 1963 年, 剑桥大学在 ALGOL 的基础上发展了 CPL 语言 1967 年, Ole- Johan Dahl 和 Kristen Nygaard, 发布 Simula 年, Xerox 的 Alan Kay 发明 Smalltalk 1983 年, AT&T 实验室 Bjarne Stroustrup 发明 C++ 语言 2003 年, 微软公司发布了 C# 语言 2

147 C++ 语言的历史 1979 年, AT&T 实验室 Dr. Bjarne Stroustrup 开始发明 开始的版本称为 : C with Classes 1983 年 8 月, 第一个 C++ 实现投入使用 1983 年 10 月, 正式命名为 C++ (CPlusPlus) 1985 年 10 月, Bjarne 完成了经典巨著 The C++ Programming Language ( 第一版 ) 3

148 C++ 标准的发展 1989 年, C++2.0 版发布 1994 年, ANSI C++ 标准发布 1998 年, ANSI 和 ISO 联合发布 C++98 标准 加入 STL (Standard Template Library) 泛型设计 2003 年, ISO 的 C++ 标准委员会发布 C++03 标准 2005 年, Library Technical Report 1 (TR1) 技术报告发布 4

149 C++11 标准 2011 年 9 月, ISO 标准委员会通过了新的 C++ 标准 -- C++11 5

150 常用的 C++ 编译器 GCC Visual C Dev C++ Eclipse Borland C++Builder 6

151 第一个面向对象语言 :Simula Simula 1967 年, Ole-Johan Dahl 和 Kristen Nygaard 发布 Simula 67 提出了类 (class) 和子类 (subclass) 的概念 程序设计语言发展史上的一个重要的里程碑

152 C++ 之父 Bjarne Stroustrup AT&T Fellow, AT&T Labs - Research Distinguished Professor Holder of the College of Engineering Chair Computer Science at Texas A&M University C++ Bible The C++ Programming Language (4th Edition) Addison-Wesley ISBN May

153 从客观事物抽象出类的例子 郭炜刘家瑛 北京大学程序设计实习

154 例 : 客观事物 类 写一个程序, 输入矩形的宽和高, 输出面积和周长 高 宽 矩形 矩形的属性 宽和高 两个变量, 分别代表宽和高 对矩形的操作 设置宽和高 计算面积 计算周长 2

155 例 : 客观事物 类 带函数的结构体 封装 矩形类 int 宽 ; w; int 高 ; h; Area(); 设置宽, 高 ; 计算面积 Perimeter() (); ; 计算周长 Init( ); (); 成员变量 成员函数 类的成员 3

156 class CRectangle { public: int w, h; void Init( int w_, int h_ ) { w = w_; h = h_; } int Area() { return w * h; } int Perimeter() { return 2 * ( w + h ); } }; // 必须有分号 4

157 int main() { int w, h; CRectangle r; //r 是一个对象 cin >> w >> h; r.init(w, h); cout << r.area() << endl << r. Perimeter(); return 0; } 类定义的变量 类的实例 对象 5

158 对象的内存分配 对象的内存空间 对象的大小 = 所有成员变量的大小之和 E.g. CRectangle 类的对象, sizeof(crectangle) = 8 每个对象各有自己的存储空间 一个对象的某个成员变量被改变, 不会影响到其他的对象 6

159 对象间的运算 对象之间可以用 = 进行赋值不能用 ==,!=, >, <, >=, <= 进行比较 除非这些运算符经过了 重载 7

160 访问类的成员变量和成员函数 用法 1: 对象名. 成员名 CRectangle r1, r2; r1.w = 5; r2.init(3,4); 8

161 访问类的成员变量和成员函数 用法 2: 指针 -> 成员名 CRectangle r1, r2; CRectangle * p1 = & r1; CRectangle * p2 = & r2; p1->w = 5; p2->init(3,4); //Init 作用在 p2 指向的对象上 9

162 访问类的成员变量和成员函数 用法 3: 引用名. 成员名 CRectangle r2; CRectangle & rr = r2; rr.w = 5; rr.init(3,4); //rr 的值变了,r2 的值也变 10

163 另一种输出结果的方式 void PrintRectangle(CRectangle & r) { cout << r.area() << ","<< r.perimeter(); } CRectangle r3; r3.init(3,4); PrintRectangle(r3); 11

164 类的成员函数的另一种写法 成员函数体和类的定义分开写 class CRectangle { public: int w, h; int Area(); // 成员函数仅在此处声明 int Perimeter() ; void Init( int w_, int h_ ); }; 12

165 类的成员函数的另一种写法 int CRectangle::Area() { return w * h; } int CRectangle::Perimeter() { return 2 * ( w + h ); } void CRectangle::Init( int w_, int h_ ) { w = w_; h = h_; } 调用通过 : 对象 / 对象的指针 / 对象的引用 13

166 1 类成员的可访问范围 郭炜刘家瑛 北京大学程序设计实习

167 类成员的可访问范围 关键字 -- 类成员可被访问的范围 private : 指定私有成员, 只能在成员函数内被访问 public : 指定公有成员, 可以在任何地方被访问 protected : 指定保护成员 三种关键字出现的次数和先后次序都没有限制 2

168 对象成员的访问权限 定义一个类 class classname { }; private: 私有属性和函数 public: 公有属性和函数 protected: 保护属性和函数 说明类成员的可见性 3

169 对象成员的访问权限 缺省为私有成员 class Man { int nage; // 私有成员 char szname[20]; // 私有成员 public: void SetName(char * Name){ strcpy(szname, Name); } }; 4

170 对象成员的访问权限 类的成员函数内部, 可以访问 : 当前对象的全部属性, 函数 同类其它对象的全部属性, 函数 类的成员函数以外的地方, 只能够访问该类对象的公有成员 5

171 class CEmployee { private: char szname[30]; // 名字 public : int salary; // 工资 void setname(char * name); void getname(char * name); void averagesalary(cemployee e1,cemployee e2); }; void CEmployee::setName( char * name) { strcpy( szname, name); //ok } void CEmployee::getName( char * name) { strcpy( name, szname); //ok } 6

172 void CEmployee::averageSalary(CEmployee e1,cemployee e2){ salary = (e1.salary + e2.salary )/2; } int main(){ CEmployee e; strcpy(e.szname,"tom "); // 编译错, 不能访问私有成员 e.setname( "Tom"); // ok e.salary = 5000; //ok return 0; } 设置私有成员的目的 强制对成员变量的访问一定要通过成员函数进行 设置私有成员的机制 -- 隐藏 7

173 szname char szname[5] 如果 szname 不是私有, 需要修改全部 : strcpy(man1.szname, Tom ); 如果将 szname 变为私有, 所有对 szname 的访问都是通过成员函数来进行, man1.setname( Tom ); 8