显示页面讨论过去修订反向链接回到顶部 本页面只读。您可以查看源文件,但不能更改它。如果您觉得这是系统错误,请联系管理员。 {{ :程序设计基础_13521005.pdf |}},参考本书P122页~P157页的内容(已包含无页码页22页),请你参考这本书的内容,尽量举相似的例子,在linux系统下的C++环境下,写一篇第四章知识总结和教程。用浏览器查看渲染情况。 ---- ====== 二维数组、字符数组与指针:知识总结与教程 ====== ''本页依据教材 **P122–P157** 的内容编写。这个页码区间跨了两章:**第 7 章「数据组织、筛选与排序问题的解题思路」的后半部分**(7.6.3 二维数组元素的存放顺序 → 7.10 知识巩固),以及**第 8 章「指针」的前半部分**(8.1 地址与指针 → 8.4 指针与函数)。例题沿用教材的类型,只把数据换成相似的;所有代码都在 Linux + g++ 下可直接编译运行。'' ''本章前半部分(数组的基本概念、一维数组、二维数组的定义与初始化、冒泡排序与选择排序等,P98–P121)见 [[程序设计基础:第6章]];本页之后的内容见 [[程序设计基础:第8章]]。'' ===== 一、二维数组中的元素存放顺序(7.6.3)===== 教材用图 7.10 里的 ''data[6][12]''(6 个一维数组、每个 12 个元素)说明:**在内存中二维数组的元素是按行存放的**,先存 ''data[0]'' 这一行的 12 个数据,再存 ''data[1]'' 中的 12 个数据,……(图 7.11)。 <code> 内存中的排列(行主序:行下标变化慢、列下标变化快) data[0][0] data[0][1] ... data[0][11] | data[1][0] data[1][1] ... data[1][11] | ... ^ 首地址 &data[0][0] ^ &data[1][0] </code> 教材给出的三条结论: * 二维数组一经定义,系统就为它分配**连成一片的存储区域**,容量保证装得下行数 × 列数个元素; * 这片区域有**一个首地址**,就是存放第 0 号一维数组第 0 号元素的地方,即 ''data[0][0]'' 的地址; * **数组名就是首地址的符号地址**,所以本例中 ''data'' 就标识了这个二维数组的首地址。 这个规律用一个小程序验证最直观: <code cpp> #include <iostream> using namespace std; int main() { int data[2][3] = {{1, 2, 3}, {4, 5, 6}}; for (int i = 0; i < 2; ++i) for (int j = 0; j < 3; ++j) cout << "&data[" << i << "][" << j << "] = " << &data[i][j] << endl; cout << "&data[0] = " << &data[0] << endl; // 第 0 行的地址 cout << "data = " << data << endl; // 数组名 = 首地址 return 0; } </code> 在 64 位 Linux 上,同一行内相邻元素的地址相差 **4**(''int'' 占 4 个字节),而 ''&data[0]''、''data'' 的数值都与 ''&data[0][0]'' 一致——这正是「数组名就是首地址」的证据。 ===== 二、程序 7_11.cpp:二维数组的典型应用 ===== 教材的例子是「计算每年降水总量和 6 年的年平均降水总量」,思路是**对二维数组中的每个元素进行相加,为此可以用两重计数型循环**: <code cpp> #include <iostream> using namespace std; int main() { int i = 0, j = 0; // 行号和列号,初始化为 0 float avgdata = 0.0; // 年平均降水量,初始化为 0.0 int yeardata[6]; // 保存每一年的降雨量,一维数组 int data[6][12] = { // 二维数组:6 年 × 12 个月 {1,1,1,2,3,4,4,5,4,3,1,2}, {1,2,1,2,3,4,4,5,4,3,2,2}, {1,2,1,1,3,4,6,4,4,3,1,2}, {2,1,2,2,3,5,4,5,4,2,2,1}, {2,1,1,2,3,5,6,5,4,3,1,1}, {1,2,1,2,3,3,5,3,4,3,2,1} }; for (i = 0; i < 6; i++) { int sum = 0; // 计算 12 个月总量前先初始化为 0 for (j = 0; j < 12; j++) sum = sum + data[i][j]; // 累加每个月的降水量 yeardata[i] = sum; cout << "第" << i << "年降水总量为: " << yeardata[i] << " 单位" << endl; } for (i = 0; i < 6; i++) avgdata = avgdata + yeardata[i]; // 累加每一年的降水量 avgdata = avgdata / 6.0; // 计算 6 年的年平均降水量 cout << "6 年平均降水量为: " << avgdata << endl; return 0; } </code> 编译运行: <code bash> g++ -Wall -o rain rain.cpp && ./rain 第0年降水总量为: 31 单位 第1年降水总量为: 33 单位 第2年降水总量为: 32 单位 第3年降水总量为: 33 单位 第4年降水总量为: 34 单位 第5年降水总量为: 30 单位 6 年平均降水量为: 32.1667 </code> 教材留的思考题:**对二维数组元素的赋值是在定义初始化时整体完成的,如果不这样做,能否一个元素一个元素地赋值?** 可以——用两重循环逐个 ''cin >> data[i][j]'' 即可(见下面任务 7.10 与思考 7.7 的写法);整体初始化只能写在定义处。 **相似例子:6 名学生、4 门课的成绩处理。** 行表示学生、列表示课程,求每名学生的总分与平均分,再求全体学生总分的平均值——结构与降水统计完全一样: <code cpp> #include <iostream> using namespace std; int main() { int score[6][4] = { // 6 名学生 × 4 门课 {88, 76, 92, 85}, {95, 89, 90, 93}, {60, 72, 68, 75}, {78, 81, 77, 80}, {90, 85, 88, 91}, {55, 66, 70, 62} }; int total[6]; double avg = 0.0; for (int i = 0; i < 6; ++i) { int sum = 0; for (int j = 0; j < 4; ++j) sum += score[i][j]; // 一行求和 = 一名学生的总分 total[i] = sum; cout << "第" << i + 1 << "名学生的总分:" << total[i] << ",平均分:" << total[i] / 4.0 << endl; } for (int i = 0; i < 6; ++i) avg += total[i]; avg = avg / 6.0; cout << "6 名学生总分的平均值为:" << avg << endl; return 0; } </code> 运行结果(总分依次为 341、367、275、316、354、253): <code> 第1名学生的总分:341,平均分:85.25 第2名学生的总分:367,平均分:91.75 第3名学生的总分:275,平均分:68.75 第4名学生的总分:316,平均分:79 第5名学生的总分:354,平均分:88.5 第6名学生的总分:253,平均分:63.25 6 名学生总分的平均值为:317.667 </code> ===== 三、任务 7.10:根据用户输入的年份和月份输出该月的天数 ===== 要求运行结果: <code> 请输入年份:2006 请输入月份:8 2006年8月有 31 天 </code> 解题思路是查表,一年里每个月的天数如表 7.3。 ^ 年份 ^ 1 月 ^ 2 月 ^ 3 月 ^ 4 月 ^ 5 月 ^ 6 月 ^ 7 月 ^ 8 月 ^ 9 月 ^ 10 月 ^ 11 月 ^ 12 月 ^ | 常年 | 31 | 28 | 31 | 30 | 31 | 30 | 31 | 31 | 30 | 31 | 30 | 31 | | 闰年 | 31 | 29 | 31 | 30 | 31 | 30 | 31 | 31 | 30 | 31 | 30 | 31 | 判断当年是否为闰年的两个条件(教材原文): * 年份能被 4 整除但不能被 100 整除的是闰年; * 年份能被 400 整除的是闰年。 写成 if 语句就是 ''if (year%4==0 && year%100!=0 || year%400==0)''。由于只有常年与闰年的不同,只要定义一个二维数组来存储每个月的具体天数就够了: <code cpp> int arrmonth[2][12] = { {31,28,31,30,31,30,31,31,30,31,30,31}, // 常年 {31,29,31,30,31,30,31,31,30,31,30,31} // 闰年 }; </code> **注意下标对齐**:一年中的月份从 1 到 12,而数组下标从 0 到 11,所以**第 k 个月的天数应写为 ''arrmonth[行][k-1]''**。 教材参考程序 7_14.cpp(已把声明与定义的返回类型统一为 ''void'',并去掉重复注释行): <code cpp> #include <iostream> using namespace std; void validate(int year, int month); // 声明有判断天数的自定义函数 int main() { int year = 0; int month = 1; cout << "请输入年份:"; cin >> year; cout << "请输入月份:"; cin >> month; for (; (month < 1 || month > 12); ) // 判断输入月份的有效性 { cout << "您输入的月份无效。"; cout << "请再次输入月份:"; cin >> month; } validate(year, month); // 调用判断天数的函数 return 0; } void validate(int year, int month) // 定义判断天数的函数 { int arrmonth[2][12] = { {31,28,31,30,31,30,31,31,30,31,30,31}, {31,29,31,30,31,30,31,31,30,31,30,31} }; if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) cout << year << "年" << month << "月有" << arrmonth[1][month-1] << "天" << endl; else cout << year << "年" << month << "月有" << arrmonth[0][month-1] << "天" << endl; } </code> 教材专门解释了第 18–23 行的 **for 循环输入校验**技巧:这条 for 语句只有判断表达式 2,没有求解表达式 1 和 3。表达式 2 的内容是 ''(month<1 || month>12)'',凡是月份小于 1 或大于 12 时表达式的值为 1,执行循环体;否则表达式的值为 0,立即退出循环——这条语句非常简练地实现了「提醒重新输入月份」的功能。教材最后问「能否使用 while 语句来实现这个功能?」,可以,而且更直观: <code cpp> while (month < 1 || month > 12) { cout << "您输入的月份无效。请再次输入月份:"; cin >> month; } </code> **相似例子:把查表法用到「一年中的第几天」。** 输入年份、月份、日期,求这一天是当年的第几天(同样查表 + 闰年判断 + 累加): <code cpp> #include <iostream> using namespace std; int dayOfYear(int year, int month, int day) { int arrmonth[2][12] = { {31,28,31,30,31,30,31,31,30,31,30,31}, {31,29,31,30,31,30,31,31,30,31,30,31} }; int row = (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) ? 1 : 0; int sum = 0; for (int k = 1; k < month; ++k) // 把前面整月的天数累加起来 sum += arrmonth[row][k - 1]; return sum + day; // 再加上本月的第几天 } int main() { cout << "2006 年 8 月 18 日是这一年的第 " << dayOfYear(2006, 8, 18) << " 天" << endl; return 0; } </code> 前 7 个月的天数之和为 31+28+31+30+31+30+31 = 212,再加 18,结果是 **230**。 ===== 四、7.7 知识拓展:字符数组 ===== ==== 4.1 字符数组的定义和初始化(7.7.1)==== 教材说:**字符数组就是字符串**,有两种常用的定义字符数组的方法。 **方法 1:指明最大字符数。** <code> char 字符数组名[字符串最大字符数 + 1] = "字符串"; </code> 例如 ''char A[8] = "Beijing";''。字符串 ''Beijing'' 有 7 个字符,而 A 数组的元素个数是 8,这是因为在存储了 7 个字符之后还要加入一个**终止符 ''\0''**(图 7.12)。如果定义的最大字符数比初始化的字符个数大,则在内存中补 ''\0'',例如 ''char C[10] = "include";''(图 7.13): <code> A : B e i j i n g \0 下标 0 1 2 3 4 5 6 7 C : i n c l u d e \0 \0 \0 下标 0 1 2 3 4 5 6 7 8 9 </code> 反过来,**如果初始化时字符串长度比预定义的最大字符数大,则会产生错误**(例如 ''char a[5] = "hello";'' 编译通不过),此时可用方法 2。 **方法 2:不说明数组元素个数。** <code> char 字符数组名[] = "字符串"; </code> 例如 ''char h[] = "Tsinghua";''——这种定义方式省略了数组中最多字符数,但是系统会根据初值的情况来补上数组的长度(8 个字符 + 1 个 ''\0'',共 9 个元素)。 <code cpp> #include <iostream> #include <cstring> using namespace std; int main() { char A[8] = "Beijing"; char h[] = "Tsinghua"; cout << "A = " << A << ",strlen(A) = " << strlen(A) << ",sizeof(A) = " << sizeof(A) << endl; cout << "h = " << h << ",strlen(h) = " << strlen(h) << ",sizeof(h) = " << sizeof(h) << endl; return 0; } </code> <code> A = Beijing,strlen(A) = 7,sizeof(A) = 8 h = Tsinghua,strlen(h) = 8,sizeof(h) = 9 </code> **要分清两个长度**:''strlen'' 数到 ''\0'' 为止(字符个数),''sizeof'' 是数组占用的字节数(含 ''\0'' 与补位)。 ==== 4.2 字符数组元素的输入/输出(7.7.2)==== **(1)把字符数组中的元素逐个输入/输出**,这种输入/输出通常采用循环语句实现。 【任务 7.11】将从键盘输入的 10 个字符依次送给数组 a 中的各个元素,并将数组 a 中的元素按倒序输出(程序 7_15.cpp): <code cpp> #include <iostream> using namespace std; int main() { int i; char a[10]; cout << "input ten character:"; for (i = 0; i < 10; i++) // 循环输入字符 cin >> a[i]; cout << endl; for (i = 9; i >= 0; i--) // 循环倒序输出 cout << a[i]; cout << endl; return 0; } </code> <code> input ten character: abcdefghij jihgfedcba </code> 注意:这种逐个字符的写法**不会自动补 ''\0''**,所以只能用循环逐字符输出、不能整体输出 a;另外 ''cin >> a[i]'' 会跳过空格与回车,若要连空格一起读进来,应改用 ''cin.get(a[i])''。 **(2)把字符数组作为字符串进行整体输入/输出**:在 cin 中只给出字符数组名,在 cout 中也只给出字符数组名。 【任务 7.12】将两个字符串输入字符数组,并把两个数组中的字符串输出(程序 7_16.cpp): <code cpp> #include <iostream> using namespace std; int main() { char a1[40], a2[40]; cout << "input two strings:"; cin >> a1 >> a2; // 输入两个字符串 cout << "a1=" << a1 << "," << "a2=" << a2 << endl; // 输出两个字符串 return 0; } </code> <code> Good Luck a1=Good,a2=Luck </code> 教材的程序说明有两条,非常重要: * 在输入字符串时,**遇到空格或 Enter 键,计算机就认为一个字符结束**,紧接着的非空字符作为一个新的字符串的开始,并且计算机会自动地给每一个字符串后面加一个 ''\0'' 以示结尾。所以 ''cin >> a1 >> a2'' 输入 ''Good Luck'' 得到的是 ''Good'' 和 ''Luck'' 两个串。 * 如果要输入**一行**(包括空格字符)作为一个字符串送到字符数组中,就需要调用函数 ''cin.getline(str, n)'':第一个参数 ''str'' 为字符数组名,第二个参数 ''n'' 为允许输入的最大字符个数。例如: <code cpp> char a[10]; cin.getline(a, 10); </code> 输入 ''C C++ C#'',则这个含有空格的字符数组 a 的内容为 ''C C++ C#''(''getline'' 会自动补上 ''\0'')。 * 一个字符数组作为一个字符串输出时,**必须保证数组中包括字符串结束符 ''\0''**。当遇到 ''\0'',字符数组自动输出结束,但 ''\0'' 不输出。 **相似例子:输入一行文字,统计字母、数字、空格、其他字符的个数。** <code cpp> #include <iostream> #include <cstring> using namespace std; int main() { char line[100]; cout << "请输入一行文字:" << endl; cin.getline(line, sizeof(line)); int letters = 0, digits = 0, spaces = 0, others = 0; for (int i = 0; line[i] != '\0'; ++i) // 以 '\0' 作为循环结束条件 { if ((line[i] >= 'a' && line[i] <= 'z') || (line[i] >= 'A' && line[i] <= 'Z')) letters++; else if (line[i] >= '0' && line[i] <= '9') digits++; else if (line[i] == ' ') spaces++; else others++; } cout << "字母 " << letters << " 个,数字 " << digits << " 个,空格 " << spaces << " 个,其他 " << others << " 个" << endl; cout << "字符串长度为 " << strlen(line) << endl; return 0; } </code> <code> 请输入一行文字: I am 18 years old. 字母 11 个,数字 2 个,空格 4 个,其他 1 个 字符串长度为 18 </code> **一个常见坑**:''cin >>'' 之后缓冲区里残留着回车,紧接着的 ''cin.getline'' 会读到一个空行。解决方法是中间加一条 ''cin.ignore();'': <code cpp> int n; char s[100]; cin >> n; cin.ignore(); // 吃掉残留的换行符 cin.getline(s, sizeof(s)); </code> ===== 五、7.8 思考与实训 ===== ==== 思考 7.7:以矩阵加法为例理解二维数组的用法 ==== 已知 A、B 两个 3×3 矩阵,求 C = A + B。教材要求用**二重循环**来做,外层循环以行号 i 为控制变量,内层循环以列号 j 为控制变量,循环体为 <code cpp> C[i][j] = A[i][j] + B[i][j]; </code> 教材强调:**矩阵相加的一个重要规则是两个相加矩阵的维数必须相同**,也就是说一个 2×3 矩阵只能与另一个 2×3 的矩阵相加。若用手工写,3×3 要写 9 条赋值语句,不如用循环。 按教材给出的步骤(声明 3 个二维数组 → 提示输入矩阵的行与列 → 键盘按行接收 A 和 B 的值 → 相加 → 通过两个 for 循环显示 3 个矩阵)写出的完整程序: <code cpp> #include <iostream> using namespace std; int main() { int A[3][3] = {{3,3,2},{5,1,3},{4,3,2}}; int B[3][3] = {{8,6,3},{4,9,5},{5,3,2}}; int C[3][3] = {{0,0,0},{0,0,0},{0,0,0}}; for (int i = 0; i < 3; ++i) // 加法可以放在初始化循环里一起做 for (int j = 0; j < 3; ++j) C[i][j] = A[i][j] + B[i][j]; cout << "数组A\t\t数组B\t\t数组C" << endl; for (int i = 0; i < 3; ++i) { for (int j = 0; j < 3; ++j) cout << A[i][j] << " "; cout << "\t"; for (int j = 0; j < 3; ++j) cout << B[i][j] << " "; cout << "\t"; for (int j = 0; j < 3; ++j) cout << C[i][j] << " "; cout << endl; } return 0; } </code> <code> 数组A 数组B 数组C 3 3 2 8 6 3 11 9 5 5 1 3 4 9 5 9 10 8 4 3 2 5 3 2 9 6 4 </code> 键盘输入版本的关键是**按行接收**:矩阵的值是按行接收的,首先接收第一行的值,然后接收第二行的值,以此类推;每行中连续地接收每一列的值,因而**必须用两个 for 循环**——第一个 for 逐行遍历,内部的 for 逐列遍历: <code cpp> int A[2][3], B[2][3]; cout << "请输入矩阵 A 的 2 行 3 列共 6 个元素:" << endl; for (int i = 0; i < 2; ++i) for (int j = 0; j < 3; ++j) cin >> A[i][j]; </code> **相似例子:矩阵转置。** 把 n×m 矩阵变成 m×n,正是「行列下标互换」的练习: <code cpp> #include <iostream> using namespace std; int main() { const int N = 2, M = 3; int a[N][M] = {{1,2,3},{4,5,6}}; int b[M][N]; // b 的行数 = a 的列数 for (int i = 0; i < N; ++i) for (int j = 0; j < M; ++j) b[j][i] = a[i][j]; // 行列下标互换 for (int i = 0; i < M; ++i) { for (int j = 0; j < N; ++j) cout << b[i][j] << " "; cout << endl; } return 0; } </code> <code> 1 4 2 5 3 6 </code> ==== 思考 7.8:打印杨辉三角形 ==== 教材指出:由于图形是二维的,所以采用二维数组,用 ''a[i][j]'' 表示第 i 行、第 j 列的元素;为配合数组的定义规则,设三角形的首行为第 0 行、最左边的一列为第 0 列。于是 * 第 0 列的元素(''a[i][0]'',i = 0,1,2,…,n)和对角线上的元素(''a[i][i]'')的值都是 1; * 对于其余的数,可以利用上一行的结果导出:**''a[i][j] = a[i-1][j-1] + a[i-1][j]''**。 教材只给了 C 语言描述(两个 for 循环),要求自己完成整个程序的编写并上机调试。完整程序如下: <code cpp> #include <iostream> #include <iomanip> using namespace std; int main() { const int N = 7; int a[N][N] = {0}; for (int i = 0; i < N; ++i) // ① 第 0 列与对角线上的元素都是 1 a[i][0] = a[i][i] = 1; for (int i = 2; i < N; ++i) // ② 其余的元素由上一行推出 for (int j = 1; j < i; ++j) a[i][j] = a[i-1][j-1] + a[i-1][j]; for (int i = 0; i < N; ++i) // 输出 { for (int j = 0; j <= i; ++j) cout << setw(6) << a[i][j]; cout << endl; } return 0; } </code> <code> 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 </code> 要点:这里用到了**上一行的结果**,所以 i 要从 2 开始、j 要从 1 开始;第 0 列和对角线上的 1 是递推的边界条件,必须先赋值。 ==== 思考 7.9:数字电话加密 ==== 某一军事机构采用数字电话传递军事情报数据,数据是 4 位整数。加密规则:**每位数字加上 5 除以 10,所得余数代替该位上的数字,然后再将第一位和第四位交换、第二位和第三位交换**,成为加密后的数字。 教材给的是带 ''<语句块>'' 占位的框架(并留下 ''retrun 0;'' 的拼写错误),要求分析算法并补全。完整程序: <code cpp> #include <iostream> using namespace std; int main() { int b, i, a[4], t; // b 为 4 位整数,a 存放各位数字,t 为中间变量 cin >> b; // 输入 4 位整数 for (i = 0; i < 4; i++) // 将 b 按位存入 a(a[0] 是个位,a[3] 是千位) { a[i] = b % 10; b = b / 10; } for (i = 0; i < 4; i++) // 对每位数字做加 5 除 10 求余运算 a[i] = (a[i] + 5) % 10; for (i = 0; i < 2; i++) // 第一位和第四位交换,第二位和第三位交换 { t = a[i]; a[i] = a[3 - i]; a[3 - i] = t; } for (i = 3; i >= 0; i--) // 从高位到低位输出加密后的数字 cout << a[i]; cout << endl; return 0; } </code> <code bash> g++ -Wall -o crypt crypt.cpp && echo 1234 | ./crypt 9876 </code> 核对规则:1234 各位加 5 取余得 6、7、8、9(即 6789),第一位与第四位交换得 9786,第二位与第三位交换得 **9876**,与程序输出一致。 ==== 思考 7.10:通过结构体实现一个基本的图书馆管理系统 ==== 该系统维护一个图书目录以及一个借书和还书事务的登记簿;使用这个系统可以增加图书的详细信息、记录借书/还书事务以及显示图书在库情况。教材把它拆成 4 步,并给出了 N-S 图(图 7.16、图 7.17)。 **(1)定义一个存储图书详细信息的结构体**,内容包括图书号、图书名、作者名、在馆图书数目: <code cpp> struct book_st { int book_id; // 图书号 char book_nm[30]; // 图书名 char author[30]; // 作者名 int copies; // 在馆图书数目 }; </code> **(2)定义一个存储借书/还书记录的结构体。** 其中借书/还书的日期也是一个结构体,此时需要**结构体的嵌套调用**: <code cpp> struct date_st // 定义日期结构体 { int month; // 定义月 int day; // 定义日 int year; // 定义年 }; struct tran_st // 定义借书/还书结构体 { char tran_type; // 事件类型是借还是还 struct date_st tran_dt; // 定义 date_st 类型结构体 }; </code> **(3)声明这两种结构体类型的变量**:为方便设计,假设要记录 4 本书的详细信息和 8 个事务。 <code cpp> struct book_st books[4]; struct tran_st trans[8]; </code> **(4)针对系统设计的复杂性和软件工程模块化设计思想,把功能分解为 3 个模块**:模块 1 增加图书的详细信息;模块 2 记录借书/还书事务;模块 3 显示图书在馆情况。教材要求先设计一个操作菜单界面,为避免错误输入选项,采用**一个循环的形式**建立菜单界面,用 if 语句判断 choice 的值来确定所要执行的功能。在教材框架上补全后的完整程序: <code cpp> #include <iostream> using namespace std; struct date_st { int month, day, year; }; struct book_st { int book_id; char book_nm[30]; char author[30]; int copies; }; struct tran_st { char tran_type; struct date_st tran_dt; }; int main() { struct book_st books[4]; // 记录 4 本书的详细信息 struct tran_st trans[8]; // 记录 8 个事务 int nbook = 0, ntran = 0; // 当前已记录的数量 char flag = 'y'; int choice = 0; while (choice != 4) // 4 表示离开 { cout << endl; cout << "选择您所需要的功能:" << endl; cout << "1.添加书目" << endl; cout << "2.借阅/归还" << endl; cout << "3.图书在馆信息记录" << endl; cout << "4.离开" << endl; cout << "请选择:"; cin >> choice; if (choice == 1) // 模块 1:增加图书的详细信息 { flag = 'y'; for (int i = nbook; i < 4 && flag == 'y'; i++) { books[i].book_id = i + 1; // 图书号加 1 cout << "提示输入此图书的书名: "; cin >> books[i].book_nm; cout << "提示输入此图书的作者: "; cin >> books[i].author; cout << "提示输入此图书号入馆数目: "; cin >> books[i].copies; nbook++; cout << "是否继续(y/n): "; cin >> flag; } } else if (choice == 2) // 模块 2:记录借书/还书事务 { flag = 'y'; for (int i = ntran; i < 8 && flag == 'y'; i++) { int id; cout << "提示输入图书号: "; cin >> id; cout << "提示是借书(Issue)还是还书(Return): "; cin >> trans[i].tran_type; for (int k = 0; k < nbook; k++) if (books[k].book_id == id) { if (trans[i].tran_type == 'I' && books[k].copies > 0) books[k].copies--; // 在馆数目减 1 else if (trans[i].tran_type == 'R') books[k].copies++; // 在馆数目加 1 } cout << "提示输入月、日、年: "; cin >> trans[i].tran_dt.month >> trans[i].tran_dt.day >> trans[i].tran_dt.year; ntran++; cout << "是否继续(y/n): "; cin >> flag; } } else if (choice == 3) // 模块 3:显示图书在馆情况 { cout << "图书号\t在馆情况" << endl; for (int i = 0; i < nbook; i++) cout << books[i].book_id << "\t" << books[i].copies << endl; } } cout << "再见!" << endl; return 0; } </code> 要点回顾:结构体的成员可以是**另一种结构体**(''trans[i].tran_dt.month'' 是二级访问);结构数组的每个元素都是同一种结构体;''flag'' 控制「是否继续」的循环,正是教材 N-S 图中 ''for(i=0;i<4 && flag=='y'; i++)'' 的写法;图书号用 ''books[i].book_id = i + 1;'' 自动加 1。 ==== 思考 7.11:去掉 while 循环会怎样 ==== 教材问:把 ''while()'' 循环去掉,输入 1、2、3、4 以外的选项,观察有什么不同。 答案:菜单只会出现**一次**。''while (choice != 4)'' 的作用是「只要不选择离开就重新显示菜单」,去掉之后程序执行完一次选择就走到 ''return 0'' 结束;输入非法选项(例如 5)时,任何 if 分支都不匹配,程序什么都不做便退出。这正是教材强调「为避免错误输入选项,采用一个循环的形式建立菜单界面」的原因。 ===== 六、7.9 小结(教材要点)===== - **(1)** 数组属于**构造类型**的数据结构,其特点是利用**下标**来区分同一类型的不同数据。 - **(2)** 数组类型的所有元素按顺序(由下标决定)存放在一个**连续的存储空间**中。 - **(3)** 数组名是数组的**符号地址**,是数组中第一个元素的存放地址。 - **(4)** 由于数组的构造方法采用顺序存储方式,改变下标就可以按顺序访问每一个元素,因而操作简便快捷,在程序设计中大量使用。 - **(5)** 数组需要确定的空间,因此在定义时要用**常量表达式**来定义数组元素的个数;在程序中只能少用而不能多用,否则会出错。 - **(6)** 排序在程序设计中占很重要的地位,本章讲了两个比较简单而又实用的排序方法——**冒泡排序法**和**选择排序法**,掌握这两种方法的实质十分重要。 - **(7)** 普通数组中的元素是单一类型的数据;结构体是由**不同类型**的数据所组成的,如果将某种结构体当作一个元素,则元素均为同一种结构体的数组称为**结构数组**。 - **(8)** 以**一维数组作为元素**的数组称为二维数组。比如一维数组有 12 个元素、下标从 0 到 11,以这样的 6 个一维数组作为元素、名为 data 的整型数组定义为 ''int data[6][12];'',这样的二维数组第一个下标为 0,…,5,第二个下标为 0,…,11。 - **(9)** 二维数组可视为**矩阵**,第一个下标为**行号**,第二个下标为**列号**。如何依行号列号对二维数组中的元素进行操作,是必须掌握的。 ===== 七、7.10 知识巩固(试题 1–8)===== **【试题 1】** 以下能正确定义一维数组的选项是 ______。 <code cpp> A. int a[5] = {0,1,2,3,4,5}; B. char a[] = {0,1,2,3,4,5}; C. char a = {'A','B','C'}; D. int a[5] = "0123"; </code> 答案:**B**。 * A 错在**初值个数超过数组长度**(5 个元素给了 6 个初值); * C 错在**没有下标**,''a'' 只是一个 char 变量,装不下 3 个字符; * D 错在**类型不匹配**,不能把字符串常量赋给 int 数组; * B 合法:由初值的个数自动确定数组长度为 6。 **【试题 2】** 以下程序的输出结果是 ______。 <code cpp> int main() { int i,a[10]; for(i=9;i>=0;i--) a[i]=10-i; cout<<a[2]<<a[5]<<a[8]; return 0; } </code> A. 258 B. 741 C. 852 D. 369 答案:**C**。赋值关系是 ''a[i] = 10 - i'',所以 ''a[2]=8''、''a[5]=5''、''a[8]=2'',依次输出得到 852。 **【试题 3】** 以下能正确定义二维数组的是 ______。 <code cpp> A. int a[][3]; B. int a[][3] = {2*3}; C. int a[][3] = {}; D. int a[2][3] = {{1},{2},{3,4}}; </code> 答案:**C**(按教材的判分口径)。 * A 错在**行数没有给出、又没有初值**,编译器无法确定要分配多少空间; * D 错在**初值的行数(3 行)超过了定义的行数(2 行)**; * C 给出了列数 3 与空的初始化列表,合法; * B 的 ''{2*3}'' 在现代 g++ 下其实也能编译通过(''2*3'' 是常量表达式,行数推为 1),教材是按「初始化列表中不应出现算式」的口径把它排除的——**在 Linux 上试着编译一下就知道了**,这也是理解「定义数组要用常量表达式」的一个好例子。 **【试题 4】** 有以下程序,运行后的输出结果是 ______。 <code cpp> int main() { int a[3][3], *p, i; p = &a[0][0]; for(i=0;i<9;i++) p[i] = i; for(i=0;i<3;i++) cout<<a[1][i]; return 0; } </code> A. 012 B. 123 C. 234 D. 345 答案:**D**。二维数组在内存中按行存放,''p = &a[0][0]'' 之后 ''p[i]'' 就是「第 i 个元素」:''p[0..2]'' 是第 0 行(0、1、2),''p[3..5]'' 是第 1 行(3、4、5),''p[6..8]'' 是第 2 行(6、7、8)。输出第 1 行的三个元素就是 **345**。这题把「二维数组按行存放」与「指针下标」两个知识点串在了一起。 **【试题 5】** 以下程序的输出结果是 ______。 <code cpp> int main() { int num=0; while (num<=2) { num++; cout<<num<<endl; } return 0; } </code> A. 1 / 2 / 3 / 4(各占一行) B. 1 / 2 / 3(各占一行) C. 1 / 2 D. 1 答案:**B**。条件 ''num<=2'' 在 num 为 0、1、2 时成立:先自增再输出 1、2、3,num 变成 3 时条件不成立,退出循环。 **【试题 6】** 有下面的程序,若要程序输出 2,从键盘输入的值为 ______。 <code cpp> int main() { int s=0,a=0,n; cin>>n; do { s+=1; a=a-2; } while(a!=n); cout<<s<<endl; return 0; } </code> A. −1 B. −3 C. −4 D. 0 答案:**C**。''do…while'' 先执行后判断:第一轮 ''s=1、a=−2'',若 ''n ≠ −2'' 则继续;第二轮 ''s=2、a=−4'',此时 ''n = −4'' 使 ''a!=n'' 为假,循环结束,输出 2。 **【试题 7】** 有以下程序,运行后的输出结果是 ______。 <code cpp> int main() { int a=1,b; for(b=1;b<=10;b++) { if(a>=8) break; if(a%2==1) {a+=5; continue;} a-=3; } cout<<b<<endl; } </code> A. 3 B. 4 C. 5 D. 6 答案:**B**。逐轮跟踪: ^ 轮次 b ^ 进入时的 a ^ 过程 ^ 结束后的 a ^ | 1 | 1 | a 为奇数 → a += 5,continue | 6 | | 2 | 6 | a 为偶数 → a −= 3 | 3 | | 3 | 3 | a 为奇数 → a += 5,continue | 8 | | 4 | 8 | a >= 8 → break 跳出循环 | 8 | 跳出时 b = 4,输出 **4**。 **【试题 8】** 以下选项中不能正确把 cl 定义成结构变量的是 ______。 <code cpp> A. typedef struct B. struct color cl { int red; { int red; int green; int green; int blue; int blue; } COLOR; }; COLOR cl; C. struct color D. struct { int red; { int red; int green; int green; int blue; int blue; } cl; } cl; </code> 答案:**A**。A 只是用 typedef 给「无名结构体」起了一个类型别名 COLOR,**始终没有定义变量 cl**,要再写一条 ''COLOR cl;'' 才会产生变量。C、D 都在结构体定义的右括号后面直接写变量名 cl,是「定义类型的同时定义变量」的合法写法。B 一栏在书上的排版是 ''struct color cl { … }; COLOR cl;'',这种写法本身不成立(结构体名后面不能直接跟变量名),阅读时按「先定义类型、再由 ''COLOR cl;'' 定义变量」的意思理解即可——结论仍然是 A:只有 A 自始至终没有出现变量名。 ===== 八、第 8 章 指针:教学目标与内容要点 ===== 教材开篇就点明:**指针是 C/C++ 语言中的一个重要概念**。掌握指针的用法,可使程序简洁、高效、灵活。**指针是很好学的,关键是学会有关变量的地址、直接地址和间接地址等概念。** 这一章的讲法教材特意做了改变,希望引导读者通过**阅读程序和动手上机实践**来了解和掌握指针的基本概念和使用指针的编程方法,从教学实践看这是化难为易的好方法。 ^ 教学目标 ^ 内容要点 ^ | 指针的基本概念 | 指针的基本概念 | | 指针变量的定义与初始化 | 指针的定义和初始化 | | 指针运算符 | 指针赋值,间接访问运算符 | | 在涉及数组、字符串、函数与结构的程序中使用指针 | 指针与数组 | | 引用的概念,利用引用传递参数 | 用数组名给指针赋值 | ===== 九、8.1 地址与指针 ===== ==== 9.1 从 8_1.cpp 到 8_12.cpp:一步一步「加」出指针 ==== 教材用**同一段程序逐次改动一条语句**的办法讲指针,这条线索非常清楚,强烈建议在 Linux 上把这 12 个小程序挨个跑一遍: ^ 程序 ^ 改动的关键语句 ^ 运行结果与结论 ^ | 8_1.cpp | ''cout<<a[0]<<endl;'' 等 5 条 | 输出 1 3 5 7 9——数组元素的**值** | | 8_2.cpp | ''cout<<&a[0]<<endl;'' 等 5 条 | 输出 0012FF6C 一类的地址——符号 & 是**取地址运算符** | | 8_3.cpp | ''int *p=NULL; p=a; cout<<p;'' | 定义指针变量并初始化为空,p 中存的是地址值 | | 8_4.cpp | 再加 ''cout<<a<<endl;'' | 与 p 的输出相同——**数组名就是首地址** | | 8_5.cpp | 再加 ''cout<<&a<<endl;'' | 结果仍相同——''a'' 与 ''&a'' 数值一致 | | 8_6.cpp | ''cout<<*p<<endl;'' | 输出 1——符号 * 是**间接存取运算符** | | 8_7.cpp | 再加 ''cout<<&p<<endl;'' | p 自己也存放在一个地址中 | | 8_8.cpp / 8_9.cpp | 循环里 ''p=p+1;'' | 依次访问 a[0]…a[4],''&p'' 一直不变 | | 8_10.cpp | ''for(p=a;p<a+5;p++)'' | 用指针作循环控制变量,程序更简洁 | | 8_11.cpp | ''p+1''、''*(p+1)'' | p+1 指向 a[1],''*(p+1)'' 是 a[1] 的值 | | 8_12.cpp | ''p-a'' | 指针相减得到**元素下标** | 教材给出的 8_8.cpp(去掉注释后): <code cpp> #include <iostream> using namespace std; int main() { int a[5] = {1,3,5,7,9}; int *p = NULL; p = a; // p 赋值为 a 数组的地址 for (int i = 0; i < 5; i++) { cout << "i=" << i << endl; cout << "&a[" << i << "]=" << &a[i] << endl; // p 所指单元的地址 cout << "a[" << i << "]=" << *p << endl; // p 所指单元中的内容 cout << "&p=" << &p << endl; // p 自身的地址,始终不变 p = p + 1; // 指针变量加 1 } return 0; } </code> 教材要求仔细观察两点:**(1)两个相连地址值之间有什么关系?(2)''&p'' 是否变化?** 答案是:相邻元素地址相差 4——原来在内存中每一个地址单元存 8 位二进制数,而 int 型数据是 32 位二进制数,需要占有 4 个内存单元,所以数组中相邻的单元之间的地址间隔就为 4;而 ''&p'' 始终不变,因为 p 是一个固定的变量。 **一处需要动手澄清的地方**:教材接着要求把 ''&a[1]-&a[0]''、''&a[2]-&a[1]''… 打印出来,并说「观察此 4 条语句输出结果是否都为 4」。**在标准 C++ 编译器上,这几个表达式的值是 1,不是 4**——两边的类型都是 ''int *'',指针相减得到的是**相差的元素个数**,不是字节数。想看到 4,必须先把指针转成字节指针: <code cpp> cout << &a[1] - &a[0] << endl; // 输出 1(元素个数) cout << (char *)&a[1] - (char *)&a[0] << endl; // 输出 4(字节数) </code> 在 Linux 上跑一下这两行,立刻就把「指针算术的单位是元素而不是字节」讲清楚了。 ==== 9.2 指针的三个基本概念(教材总结)==== 教材以指针变量 p 为例总结出三个概念(对应图 8.2、图 8.3): - **(1) 指针变量中存的是一个地址值,而不是一般的数值。** 该地址值就是 p 所指向的那个地址单元;那个地址单元中存着什么类型的数,已经在定义 p 时声明过了。例如 ''int *p=NULL;'' 的意思是要求指针 p 去指向**存有整型数**的那些地址单元(若写成 ''float *p=NULL;'' 则指向存有浮点型数的地址单元)。''p=a;'' 经过这条语句,p 就指向了 a,读作「将 a 的地址赋给指针变量 p」。 - **(2) 既然 p 是(指针)变量,那么它也需要在内存中存放在一个地址中**,所以有一个 p 所在的地址 ''&p''。p 中的内容是可变的,但是存有指针 p 的地址相对不变,''&p'' 称为指针变量的**存放地址**。 - **(3) ''&p'' 是地址,该地址单元中的内容 p 还是一个地址,怎样表示 p 所指向的那个地址单元中的内容呢?** 那就要使用**间接存取运算符 ***。 <code cpp> int *p = NULL; int a[5] = {1,3,5,7,9}; p = a; // p 指向 &a[0] cout << *p << endl; // 输出 1,因为 * &a[0] ←→ a[0] cout << &p << endl; // p 自己的存放地址 </code> 教材强调了两个好习惯与一个提醒:**定义指针时同时将其初始化为空(NULL),这是非常重要的好习惯**(「指针变量乱指就会惹麻烦」);**要弄明白为什么要在字符串末尾补 ''\0''**;另外,8_14.cpp 中出现的 ''gets()'' 在现代 Linux + g++ 上已经**被删除**(它不检查缓冲区长度,是著名的不安全函数),要读一行输入请用 ''cin.getline()'' 或 ''fgets()''。 **相似例子:用指针求数组的最大值,并返回它的下标。** 把「指针即地址、*p 即内容、p−a 即下标」三件事一次用上: <code cpp> #include <iostream> using namespace std; int main() { int a[8] = {12, 45, 7, 39, 88, 23, 88, 15}; int *p = a; // p 指向 a[0] int *pmax = a; // 记录最大值所在的地址 for (; p < a + 8; p++) // 用指针作循环控制变量 if (*p > *pmax) pmax = p; // 记住地址,而不是只记住值 cout << "最大值是 " << *pmax << ",它在数组中的下标是 " << pmax - a << endl; // 指针相减得到下标 return 0; } </code> <code> 最大值是 88,它在数组中的下标是 4 </code> **再一个相似例子:值传递为什么换不了两个数。**(与前面函数部分呼应) <code cpp> #include <iostream> using namespace std; void swapv(int x, int y) { int t = x; x = y; y = t; } // 值传递:只换副本 void swapp(int *x, int *y) { int t = *x; *x = *y; *y = t; } // 传地址:真的换 int main() { int a = 1, b = 2; swapv(a, b); cout << "值传递之后: a=" << a << ", b=" << b << endl; // 1 2 swapp(&a, &b); cout << "传地址之后: a=" << a << ", b=" << b << endl; // 2 1 return 0; } </code> ==== 9.3 用指针遍历数组(8_10.cpp 与 8_12.cpp)==== <code cpp> #include <iostream> using namespace std; int main() { int a[5] = {1,3,5,7,9}; int *p = NULL; for (p = a; p < a + 5; p++) // p 为循环控制变量 cout << "p=" << p << " " << "*p=" << *p << endl; return 0; } </code> <code> p=0x7ffd3b2a4c30 *p=1 p=0x7ffd3b2a4c34 *p=3 p=0x7ffd3b2a4c38 *p=5 p=0x7ffd3b2a4c3c *p=7 p=0x7ffd3b2a4c40 *p=9 </code> 教材在 32 位 + Visual C++ 6.0 下的输出形如 ''0012FF6C'';换成 64 位 Linux 后地址变成 0x7ffd… 这种十二位十六进制,**比较时只看差值**(相邻仍然相差 4)。 用 ''p - a'' 表示下标(8_12.cpp): <code cpp> for (p = a; p < a + 5; p++) cout << "下标为" << p - a << " 的数组单元: p=" << p << " *p=" << *p << endl; </code> ===== 十、8.2 字符串与指针的运算 ===== **8_13.cpp:用指针变量来计算字符串的长度。** <code cpp> #include <iostream> using namespace std; int main() { char s[] = "abcdefgh"; char *p = NULL; p = s; // 让 p 赋地址值为 s 数组的地址 while (*p != '\0') // *p 作为循环控制变量 { cout << *p; // 输出 p 所指单元中的内容 p++; // p+1,指向下一个单元 } cout << endl; cout << "字符串 s 的长度为: " << p - s << endl; // 指针相减得字符个数 return 0; } </code> <code> abcdefgh 字符串 s 的长度为: 8 </code> 教材用图 8.5 解释:字符串 s 的 8 个字符分别存在 ''s[0]…s[7]'' 中,''s[8]'' 中存放的是结束符 ''\0'';''p=s;'' 让 p 指向 s 的首地址,之后用 ''*p'' 的值作为是否继续执行循环体的条件,只要 ''*p'' 的值不为 ''\0'' 就要继续循环,直到 ''*(p+8)'' 是 ''\0'' 时退出,输出(实际上是)''(p+8) - s = 8''。 **8_14.cpp:使用 gets() 向字符数组 strp 输入字符串,再用循环把它复制到 strq。** 教材提示这是理解指针运算的关键:**第 21 行是极为精炼的语句,希望大家能学会**。 <code cpp> char *p = strp; char *q = strq; while (*p) // *p 为循环控制变量 * q++ = *p++; // 复制字符,并让 q 和 p 都加 1 指向下一处 * q = '\0'; // 在 strq 的末尾加字符串的结束符 </code> 教材的说明有两点: * ''while'' 语句中的 ''*p'' 作为循环控制变量:当 ''*p'' 是一般字符时程序执行循环体;当 ''*p'' 是结束符 ''\0'' 时,就退出循环。因为 ''\0'' 的 ASCII 码值为 0,即表达式的值为「假」,所以结束循环。 * 循环体中只有一条语句 ''*q++ = *p++;'',**实际上这条语句可以等效地写成 3 条语句**:''*q = *p; q++; p++;'',意思是每复制一个字符后,让指针 q 和 p 都加 1 去指向下一处。 * 第 23 行 ''*q = '\0';'' 一定要弄明白为什么要加:没有结束符,复制出的数组在整体输出时会越界读到垃圾内容。教材还留了两个思考题:若输入 strp 的字符串长度超过 30 会出现什么情况(**缓冲区溢出**),以及如何在适当位置添加一个变量计算输入字符串的长度。 **自己动手实现库函数**(这正是 strcpy、strlen 的实质): <code cpp> char *my_strcpy(char *dst, const char *src) { char *p = dst; while ((*dst++ = *src++) != '\0'); // 赋值表达式的值就是刚复制进来的字符 return p; // 返回目标串的首地址 } int my_strlen(const char *s) { const char *p = s; while (*p != '\0') p++; return p - s; // 用指针差求长度 } </code> **8_15.cpp:将一个字符串插入到另一个字符串中。** 教材说这个任务比较难,要求把 8_15.cpp 运行两遍、观察并记下输出结果,再粗略阅读程序、大体明白它的作用。 <code cpp> #include <iostream> using namespace std; void insertstr(char *p, char *q, int k); // 声明有自定义函数 int main() { char ps[30] = "abfg"; char qs[30] = "cde"; puts(ps); // 输出字符串 ps puts(qs); // 输出字符串 qs int m = 2; // 在 ps 从 0 数起的第 m 个字符前插入 qs insertstr(ps, qs, m); puts(ps); // 输出已完成插入操作的 ps return 0; } void insertstr(char *p, char *q, int k) { char *s = NULL; char *r = NULL; s = p; r = q; int n; while (*r != '\0') // 测算 qs 串的长度 r = r + 1; n = r - q; // r - q 为所指向的字符串的长度 r = q; while (*(s + k) != '\0') // 把 ps 从第 k 个字符起的部分接到 qs 后面 { *(r + n) = *(s + k); s = s + 1; r = r + 1; } *(r + n) = '\0'; // 刚形成的 qs 串的结尾加 '\0' *s = '\0'; // ps 的左半段补 '\0' s = p; r = q; while (*r != '\0') // 把加长后的 qs 接到 ps 的 k 位置 { *(s + k) = *r; r = r + 1; s = s + 1; } *(s + k) = '\0'; // 结束符加到 (s+k) 所指的地址单元 } </code> <code bash> g++ -Wall -o insert insert.cpp && ./insert abfg cde abcdefg </code> 插入的过程(教材图 8.6 的读法):**先把 ps 中的 ''fg'' 依次放到 qs 的后面**,使 qs 从 ''cde'' 加长为 ''cdefg'';**然后使 ps 从 ''abfg'' 缩短为 ''ab''**(第 41 行 ''*s = '\0';'');**再把加长后的 qs 串接到 ps 后面**。结合程序讲解(图 8.7–8.11): * ''void insertstr(char *p, char *q, int k)'' 有 3 个形参,分别是指向字符类型的指针 p 和 q,还有一个整型变量 k。执行 ''insertstr(ps,qs,m)'' 时,相当于完成了 ''char *p=ps; char *q=qs; int k=m;'' 这 3 个赋值任务,此时 p 指向 ps 串、q 指向 qs 串、k=2(图 8.7(a)); * 函数内又定义了两个起辅助作用的指针 s 和 r,''s=p; r=q;'' 后 s 与 p、r 与 q 分别指向同一处(图 8.7(b)); * ''while(*r != '\0') r = r + 1;'' 让 r 一步步加 1,直到指向结束符 ''\0'' 时停下,此时 ''n = r - q'' 就是 qs 串的长度(图 8.8); * 第二个 while 把 ps 从第 k 个字符起的部分依次写到 qs 的尾部(图 8.9),循环退出后再补两个 ''\0'':一个给加长后的 qs,一个给缩短后的 ps(图 8.10); * 最后一个 while 把 qs 的字符逐个写到 ps 的 k 位置往后(图 8.11),''*(s+k) = '\0';'' 收尾,最终 ps 变成 ''abcdefg''。 **8_16.cpp:用指针让字符串逆序输出**(教材要求读懂后把 do…while 循环修改为 while 循环)。 <code cpp> #include <iostream> using namespace std; int main() { char shuz[] = "987654321"; char *p = &shuz[8]; // 定义指针,令其指向下标为 8 的数组单元 do { cout << *p; // 输出所指向的单元的内容 p--; // 让指针减 1 } while (p >= shuz); // p >= shuz 时继续循环 cout << endl; return 0; } </code> <code> 123456789 </code> 改成 while 循环的写法: <code cpp> char *p = &shuz[8]; while (p >= shuz) { cout << *p; p--; } </code> 注意这里的循环条件是**指针之间的大小比较**:p 从 ''&shuz[8]'' 一路减到 ''shuz'',再减就越界了,所以判断条件必须写 ''p >= shuz''。 **相似例子:用两个指针判断回文串。** <code cpp> #include <iostream> #include <cstring> using namespace std; bool isPalindrome(const char *s) { const char *left = s; const char *right = s + strlen(s) - 1; // 指向最后一个字符 while (left < right) { if (*left != *right) return false; left++; // 左指针后移 right--; // 右指针前移 } return true; } int main() { char s[100]; cin.getline(s, sizeof(s)); cout << (isPalindrome(s) ? "是回文串" : "不是回文串") << endl; return 0; } </code> ===== 十一、8.3 指针数组 ===== **以指针为单元的数组称为指针数组。** 教材图 8.12 中,指针数组 p 包含了 3 个数组单元 ''p[0]''、''p[1]''、''p[2]'',分别指向 3 处 ''&ar0[0]''、''&ar1[0]''、''&ar2[0]''。 按图 8.12 写出定义,并按图 8.13 理解「指针数组的元素及地址关系」: <code cpp> int ar0[] = {0,1,2}; int ar1[] = {1,2,3}; int ar2[] = {2,3,4}; int *p[] = {ar0, ar1, ar2}; // 指针数组 p:3 个单元分别指向上述三个数组 p[0] = &ar0[0]; p[1] = &ar1[0]; p[2] = &ar2[0]; * &p[0] = p[0]; // 与普通指针同样的对偶关系 p[0] = ar0 = &ar0[0]; * p[0] = * &ar0[0] = 0; // 即 ar0[0] </code> 教材程序 8_17.cpp: <code cpp> #include <iostream> using namespace std; int main() { int ar0[] = {0,1,2}; int ar1[] = {1,2,3}; int ar2[] = {2,3,4}; int *p[] = {ar0, ar1, ar2}; cout << "p[0]=" << p[0] << endl; // 输出 p[0] 所指向的那个地址 cout << "p[1]=" << p[1] << endl; cout << "p[2]=" << p[2] << endl; cout << "ar0:" << p[0][0] << p[0][1] << p[0][2] << endl; cout << "ar1:" << p[1][0] << p[1][1] << p[1][2] << endl; cout << "ar0:" << p[2][0] << p[2][1] << p[2][2] << endl; // 教材原文此处也写作 ar0 return 0; } </code> <code> p[0]=0x7ffc8a5b3a40 p[1]=0x7ffc8a5b3a50 p[2]=0x7ffc8a5b3a60 ar0:012 ar1:123 ar0:234 </code> (最后一行按数据应为 ''ar2:234'',教材原文的小标题写作 ''ar0'',属笔误。)教材还建议在 8_17.cpp 中加入下面这两句再运行看一看,用来确认图 8.13 画得对不对: <code cpp> cout << &p[0][0] << "=" << &ar0[0] << endl; cout << * &p[0][0] << "=" << p[0][0] << "=" << ar0[0] << endl; </code> **弄明白图 8.13 之后,你就会看出指针数组可以构成二维数组。** 教材的练习是:编写一个程序,用**指针数组**把下面的矩阵显示到屏幕上。 <code> 1 2 3 4 5 2 3 4 5 6 3 4 5 6 7 </code> 参考解答(每行一个一维数组,指针数组的元素各指向一行): <code cpp> #include <iostream> using namespace std; int main() { int r1[] = {1,2,3,4,5}; int r2[] = {2,3,4,5,6}; int r3[] = {3,4,5,6,7}; int *p[] = {r1, r2, r3}; // 指针数组:3 个元素,各指向一行 for (int i = 0; i < 3; ++i) { for (int j = 0; j < 5; ++j) cout << p[i][j] << " "; // p[i][j] 等价于 *(*(p+i)+j) cout << endl; } return 0; } </code> **要分清两个容易混淆的写法**: <code cpp> int *p[3]; // 指针数组:3 个元素,每个都是 int * int (*p)[3]; // 指向「含 3 个 int 的数组」的指针,即行指针 </code> 前者是「数组的元素是指针」,后者是「一个指针,指向一个数组」。''p[i][j]'' 在两种写法下都能写,但含义不同:前者先取第 i 个指针再取第 j 个元素,后者按行跨越。 ===== 十二、8.4 指针与函数 ===== 教材的总述:**指针与函数关系密切。** 在程序中可以使用**指针作为函数的参数**,也可以定义**函数返回值是指针类型**(即函数运行结果是给出一个内存地址),还可以定义**指针指向函数**。总之,使用很灵活,功能很强大。 ==== 12.1 函数返回指针(8.4.1)==== 【任务 8.1】编写一个程序,使其中被调用的子函数的返回值是指针:定义两个实数 x 和 y,其值由键盘输入;子函数用两个指针 p 和 q 分别指向 x 和 y,子函数的作用是**判定 x 比 y 大则返回 p,否则返回 q**。 由于这个任务有相当难度,教材采取「倒过来讲」的办法:先让大家自己编好程序,再讲解题思路。参考程序 8_18.cpp(注意在 max 前面加了一个 ''*'' 号,这就是能够返回指针的函数;''#include <iostream.h>'' 已改为现代写法): <code cpp> #include <iostream> using namespace std; float *max(float *p, float *q) // 函数,求两数中的大者 { float *r = NULL; if (*p > *q) r = p; else r = q; return r; // 返回指针 } int main() { float x, y, *s = NULL; cin >> x; cout << "x=" << x << endl; cin >> y; cout << "y=" << y << endl; s = max(&x, &y); // 实参是变量的地址 cout << "两个数中较大的数为: " << *s << endl; return 0; } </code> <code bash> g++ -Wall -o maxp maxp.cpp && printf '3.1416\n2.7182\n' | ./maxp x=3.1416 y=2.7182 两个数中较大的数为: 3.1416 </code> 教材的解题思路(归纳为 5 条): * 在函数名 max 前加 ''*'' 号,表明**该函数的返回值是指针**,该指针所指向的地址中的变量类型为 float,因此定义写成 ''float *max(float *p, float *q);'';这个类型标志要写在这一行的最前面、在 ''*'' 号前面。 * 函数有两个形式参数 p、q,都是指向 float 型变量的指针;函数体中又定义了一个指针变量 r,也是指向 float 型变量的指针。 * 主函数中定义了 x、y 为 float 型变量,其数值由键盘输入,还定义了一个指向 float 型变量的指针变量 s。最关键的一条语句是 ''s = max(&x, &y);'':因为 s 是指针变量,它指向一个 float 类型变量的地址,所以 ''max(&x,&y)'' 应该是一个**地址**;调用时 x 与 y 的地址 ''&x''、''&y'' 作为实际参数赋给形式参数 p 和 q,形成了图 8.14 所示的指向关系(p 指向 x,q 指向 y)。 * 假如从键盘输入 x = 3.1416、y = 2.7182,子函数 max(*p, *q) 被调用后 ''*p'' 为 3.1416、''*q'' 为 2.7182,这时 ''*p > *q'' 成立,于是让指针 r 指向 p 所指的地址 ''&x''(图 8.15)——**指针 r 所指向的是两数中较大的数**。 * 子函数中 ''return r'' 把指针 r 作为 max 函数的返回值,这个 r 是 x 变量的地址值 ''&x'';主函数中 ''s = max(&x,&y)'' 等价于 ''s = r'',s 与 r 的指向一致,输出 ''*s'' 就得到较大的那个数。若 y > x,则 r 指向 y,s 也指向 y。 教材的总结非常值得记住:**主函数在调用子函数时实际参数是变量的地址(指针),子函数中的形式参数也是变量的地址(指针),这样就使子程序中要操作的变量与主程序中要操作的变量完全相同。** 这正是「传地址」能修改主函数变量的原因。图 8.16 画出了整个程序的示意图。 **库函数中有许多函数是返回指针的函数**,比如将一个字符串赋值到另一个字符串的函数 ''strcpy(str1, str2)'':其中 str1 和 str2 是已声明并初始化的字符数组,函数将 str2 中的值复制到字符数组 str1 中,**并将 str1 的首地址返回**。 【思考 8.1】阅读并上机调试下列程序,要求读懂程序的意思,学会使用 strcpy(str1, str2): <code cpp> #include <iostream> #include <cstring> using namespace std; int main() { char schname1[15] = "xzhx"; char schname2[15] = "xzcit"; cout << "The old name is: " << schname1 << endl; strcpy(schname1, schname2); // 修改校名 cout << "The new name is: " << schname1 << endl; // 显示新校名 return 0; } </code> <code> The old name is: xzhx The new name is: xzcit </code> 两点提醒:''strcpy'' **不检查目标数组是否够大**(目标比源短就会溢出),工程代码应改用 ''strncpy'' 或 C++ 的 ''std::string'';返回首地址的好处是可以**链式调用**,例如 ''strcpy(str3, strcpy(str1, str2));''。 **危险示例:不要返回局部变量的地址。** <code cpp> float *bad() // 错误示范 { float t = 3.14f; return &t; // t 在函数返回时已被销毁,得到的是悬空指针 } </code> 要返回指针,就让它指向**调用者提供的变量**(如 8_18.cpp 中的 x、y)、**静态变量**或**堆上的存储**。 ==== 12.2 指向函数的指针(8.4.2)==== 教材的解释很精炼:函数是由指令序列构成的,其代码存储在连成一片的内存单元中,这些代码中的**第一个代码所在的内存地址称为首地址**,首地址是函数的**入口地址**。主函数在调用子函数时,就是让程序转移到函数的入口地址去执行。所谓**指针指向函数,就是指针的值为函数的入口地址**。把数组与函数比较:指向数组的指针是让数组的首地址赋给指针变量;指向函数的指针是让函数的入口地址赋给指针变量。 教材的例子是先用类型定义标识符 ''typedef'' 定义一个指向函数的指针类型,该类型的名字是编程者自己起的,这里用 ''MenuFood''(菜单)作为类型名: <code cpp> typedef void (*MenuFood)(); // 定义指向函数的指针类型 </code> 语句中在 typedef 后面的 ''void'' 表示 MenuFood 类型的指针所指向的函数**仅完成一系列操作,而没有返回值**。这种指向函数的指针类型定义好之后,就可以再用它定义具体的指针变量;本例是定义**带下标的变量**,即以 p 为名的指向函数的指针数组: <code cpp> MenuFood P[] = {food1, food2, food3, food4}; </code> 其中 food1、food2、food3、food4 是 4 个函数,指针 ''p[0]'' 指向 food1,''p[1]'' 指向 food2,''p[2]'' 指向 food3,''p[3]'' 指向 food4。 **相似例子:把菜单做成函数指针数组**——正适合用在思考 7.10 的图书馆系统上: <code cpp> #include <iostream> using namespace std; void food1() { cout << "1.添加书目" << endl; } void food2() { cout << "2.借阅/归还" << endl; } void food3() { cout << "3.图书在馆信息记录" << endl; } void food4() { cout << "4.离开" << endl; } typedef void (*MenuFood)(); int main() { MenuFood P[] = {food1, food2, food3, food4}; for (int i = 0; i < 4; ++i) P[i](); // 通过指针调用函数,等价于 (*P[i])() return 0; } </code> (本页的页码范围到此为止,8.4 之后的内容见 [[程序设计基础:第8章]]。) ===== 十三、Linux 上机提示与常见错误 ===== **编译与调试:** <code bash> g++ -Wall -Wextra -g -o prog prog.cpp # 警告不要忽略,-g 便于用 gdb 单步 ./prog </code> **地址与指针相关的注意事项:** * 教材的地址示例(''0012FF6C'')来自 32 位 + Visual C++ 6.0;在 64 位 Linux 下地址形如 ''0x7ffd…'',**指针变量本身占 8 字节**,而 int 仍占 4 字节,所以相邻 int 元素的地址差仍是 4。 * 打印指针建议写成 ''cout << (void *)p << endl;''(或 ''printf("%p", p)''):直接 ''cout << p'' 对 ''char *'' 输出的是字符串、对 ''int *'' 输出的是十六进制地址,两种行为容易混淆。 * **指针相减得到的是元素个数**,想得到字节数要转成 ''char *'' 再相减(见 9.1 节对教材 ''&a[1]-&a[0]'' 的说明)。 * 定义指针时立刻初始化为 ''NULL'',**使用前必须让它指向确定的单元**,否则就是野指针——段错误的头号来源。 * **不要返回局部变量的地址**;数组越界、字符串忘记补 ''\0'' 都会让程序读到垃圾数据甚至崩溃。 * ''gets()'' 在现代编译器中已被移除,读一行请用 ''cin.getline()'' 或 ''fgets()''。 **教材中的几处笔误,上机时会立刻暴露,注意识别:** * 程序 7_14.cpp:第 9 行声明为 ''int validate(int year,int month);'',而第 27 行却定义成 ''void validate(...)''。**函数声明与定义的返回类型必须一致**,否则 g++ 会报 conflicting declaration 类的错误。 * 思考 7.9 的程序框架中 ''retrun 0;'' 是 ''return 0;'' 的拼写错误。 * 8_17.cpp 输出 ar2 数据的那一行,小标题被写成 ''ar0:''。 * 8_8.cpp 之后关于 ''&a[1]-&a[0]'' 是否为 4 的说法,按标准 C++ 应为 1(元素个数),见 9.1 节。 **数组与字符串的常见错误对照:** ^ 现象 ^ 原因 ^ 改正 ^ | ''char a[5]="hello";'' 编译报错 | 5 个字符 + 1 个 ''\0'' 共 6 个字节,装不下 | 写 ''char a[6]="hello";'' 或 ''char a[]="hello";'' | | 输出字符数组出现乱码 | 数组中没有 ''\0'' 结束符 | 逐个字符赋值后手工补 ''*q = '\0';'' | | ''cin >>'' 之后 ''getline'' 读到空行 | 缓冲区里残留着回车 | 中间加一条 ''cin.ignore();'' | | ''data[0][3]=1;'' 能编译但结果怪 | 越界写入了第 1 行的第 0 个元素 | 下标控制在 0…行数−1、0…列数−1 以内 | | 查表结果总是差一个月 | 月份从 1 开始、数组下标从 0 开始 | 统一写成 ''arrmonth[行][k-1]'' | ===== 十四、知识结构导图 ===== 登录 Detach Close 该主题尚不存在 您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。 程序设计基础/第7章.txt 最后更改: 2026/10/06 22:50由 张叶安 登录