{{ :程序设计基础_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)。
内存中的排列(行主序:行下标变化慢、列下标变化快)
data[0][0] data[0][1] ... data[0][11] | data[1][0] data[1][1] ... data[1][11] | ...
^ 首地址 &data[0][0] ^ &data[1][0]
教材给出的三条结论:
* 二维数组一经定义,系统就为它分配**连成一片的存储区域**,容量保证装得下行数 × 列数个元素;
* 这片区域有**一个首地址**,就是存放第 0 号一维数组第 0 号元素的地方,即 ''data[0][0]'' 的地址;
* **数组名就是首地址的符号地址**,所以本例中 ''data'' 就标识了这个二维数组的首地址。
这个规律用一个小程序验证最直观:
#include
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;
}
在 64 位 Linux 上,同一行内相邻元素的地址相差 **4**(''int'' 占 4 个字节),而 ''&data[0]''、''data'' 的数值都与 ''&data[0][0]'' 一致——这正是「数组名就是首地址」的证据。
===== 二、程序 7_11.cpp:二维数组的典型应用 =====
教材的例子是「计算每年降水总量和 6 年的年平均降水总量」,思路是**对二维数组中的每个元素进行相加,为此可以用两重计数型循环**:
#include
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;
}
编译运行:
g++ -Wall -o rain rain.cpp && ./rain
第0年降水总量为: 31 单位
第1年降水总量为: 33 单位
第2年降水总量为: 32 单位
第3年降水总量为: 33 单位
第4年降水总量为: 34 单位
第5年降水总量为: 30 单位
6 年平均降水量为: 32.1667
教材留的思考题:**对二维数组元素的赋值是在定义初始化时整体完成的,如果不这样做,能否一个元素一个元素地赋值?** 可以——用两重循环逐个 ''cin >> data[i][j]'' 即可(见下面任务 7.10 与思考 7.7 的写法);整体初始化只能写在定义处。
**相似例子:6 名学生、4 门课的成绩处理。** 行表示学生、列表示课程,求每名学生的总分与平均分,再求全体学生总分的平均值——结构与降水统计完全一样:
#include
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;
}
运行结果(总分依次为 341、367、275、316、354、253):
第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
===== 三、任务 7.10:根据用户输入的年份和月份输出该月的天数 =====
要求运行结果:
请输入年份:2006
请输入月份:8
2006年8月有 31 天
解题思路是查表,一年里每个月的天数如表 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)''。由于只有常年与闰年的不同,只要定义一个二维数组来存储每个月的具体天数就够了:
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} // 闰年
};
**注意下标对齐**:一年中的月份从 1 到 12,而数组下标从 0 到 11,所以**第 k 个月的天数应写为 ''arrmonth[行][k-1]''**。
教材参考程序 7_14.cpp(已把声明与定义的返回类型统一为 ''void'',并去掉重复注释行):
#include
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;
}
教材专门解释了第 18–23 行的 **for 循环输入校验**技巧:这条 for 语句只有判断表达式 2,没有求解表达式 1 和 3。表达式 2 的内容是 ''(month<1 || month>12)'',凡是月份小于 1 或大于 12 时表达式的值为 1,执行循环体;否则表达式的值为 0,立即退出循环——这条语句非常简练地实现了「提醒重新输入月份」的功能。教材最后问「能否使用 while 语句来实现这个功能?」,可以,而且更直观:
while (month < 1 || month > 12)
{
cout << "您输入的月份无效。请再次输入月份:";
cin >> month;
}
**相似例子:把查表法用到「一年中的第几天」。** 输入年份、月份、日期,求这一天是当年的第几天(同样查表 + 闰年判断 + 累加):
#include
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;
}
前 7 个月的天数之和为 31+28+31+30+31+30+31 = 212,再加 18,结果是 **230**。
===== 四、7.7 知识拓展:字符数组 =====
==== 4.1 字符数组的定义和初始化(7.7.1)====
教材说:**字符数组就是字符串**,有两种常用的定义字符数组的方法。
**方法 1:指明最大字符数。**
char 字符数组名[字符串最大字符数 + 1] = "字符串";
例如 ''char A[8] = "Beijing";''。字符串 ''Beijing'' 有 7 个字符,而 A 数组的元素个数是 8,这是因为在存储了 7 个字符之后还要加入一个**终止符 ''\0''**(图 7.12)。如果定义的最大字符数比初始化的字符个数大,则在内存中补 ''\0'',例如 ''char C[10] = "include";''(图 7.13):
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
反过来,**如果初始化时字符串长度比预定义的最大字符数大,则会产生错误**(例如 ''char a[5] = "hello";'' 编译通不过),此时可用方法 2。
**方法 2:不说明数组元素个数。**
char 字符数组名[] = "字符串";
例如 ''char h[] = "Tsinghua";''——这种定义方式省略了数组中最多字符数,但是系统会根据初值的情况来补上数组的长度(8 个字符 + 1 个 ''\0'',共 9 个元素)。
#include
#include
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;
}
A = Beijing,strlen(A) = 7,sizeof(A) = 8
h = Tsinghua,strlen(h) = 8,sizeof(h) = 9
**要分清两个长度**:''strlen'' 数到 ''\0'' 为止(字符个数),''sizeof'' 是数组占用的字节数(含 ''\0'' 与补位)。
==== 4.2 字符数组元素的输入/输出(7.7.2)====
**(1)把字符数组中的元素逐个输入/输出**,这种输入/输出通常采用循环语句实现。
【任务 7.11】将从键盘输入的 10 个字符依次送给数组 a 中的各个元素,并将数组 a 中的元素按倒序输出(程序 7_15.cpp):
#include
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;
}
input ten character: abcdefghij
jihgfedcba
注意:这种逐个字符的写法**不会自动补 ''\0''**,所以只能用循环逐字符输出、不能整体输出 a;另外 ''cin >> a[i]'' 会跳过空格与回车,若要连空格一起读进来,应改用 ''cin.get(a[i])''。
**(2)把字符数组作为字符串进行整体输入/输出**:在 cin 中只给出字符数组名,在 cout 中也只给出字符数组名。
【任务 7.12】将两个字符串输入字符数组,并把两个数组中的字符串输出(程序 7_16.cpp):
#include
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;
}
Good Luck
a1=Good,a2=Luck
教材的程序说明有两条,非常重要:
* 在输入字符串时,**遇到空格或 Enter 键,计算机就认为一个字符结束**,紧接着的非空字符作为一个新的字符串的开始,并且计算机会自动地给每一个字符串后面加一个 ''\0'' 以示结尾。所以 ''cin >> a1 >> a2'' 输入 ''Good Luck'' 得到的是 ''Good'' 和 ''Luck'' 两个串。
* 如果要输入**一行**(包括空格字符)作为一个字符串送到字符数组中,就需要调用函数 ''cin.getline(str, n)'':第一个参数 ''str'' 为字符数组名,第二个参数 ''n'' 为允许输入的最大字符个数。例如:
char a[10];
cin.getline(a, 10);
输入 ''C C++ C#'',则这个含有空格的字符数组 a 的内容为 ''C C++ C#''(''getline'' 会自动补上 ''\0'')。
* 一个字符数组作为一个字符串输出时,**必须保证数组中包括字符串结束符 ''\0''**。当遇到 ''\0'',字符数组自动输出结束,但 ''\0'' 不输出。
**相似例子:输入一行文字,统计字母、数字、空格、其他字符的个数。**
#include
#include
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;
}
请输入一行文字:
I am 18 years old.
字母 11 个,数字 2 个,空格 4 个,其他 1 个
字符串长度为 18
**一个常见坑**:''cin >>'' 之后缓冲区里残留着回车,紧接着的 ''cin.getline'' 会读到一个空行。解决方法是中间加一条 ''cin.ignore();'':
int n;
char s[100];
cin >> n;
cin.ignore(); // 吃掉残留的换行符
cin.getline(s, sizeof(s));
===== 五、7.8 思考与实训 =====
==== 思考 7.7:以矩阵加法为例理解二维数组的用法 ====
已知 A、B 两个 3×3 矩阵,求 C = A + B。教材要求用**二重循环**来做,外层循环以行号 i 为控制变量,内层循环以列号 j 为控制变量,循环体为
C[i][j] = A[i][j] + B[i][j];
教材强调:**矩阵相加的一个重要规则是两个相加矩阵的维数必须相同**,也就是说一个 2×3 矩阵只能与另一个 2×3 的矩阵相加。若用手工写,3×3 要写 9 条赋值语句,不如用循环。
按教材给出的步骤(声明 3 个二维数组 → 提示输入矩阵的行与列 → 键盘按行接收 A 和 B 的值 → 相加 → 通过两个 for 循环显示 3 个矩阵)写出的完整程序:
#include
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;
}
数组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
键盘输入版本的关键是**按行接收**:矩阵的值是按行接收的,首先接收第一行的值,然后接收第二行的值,以此类推;每行中连续地接收每一列的值,因而**必须用两个 for 循环**——第一个 for 逐行遍历,内部的 for 逐列遍历:
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];
**相似例子:矩阵转置。** 把 n×m 矩阵变成 m×n,正是「行列下标互换」的练习:
#include
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;
}
1 4
2 5
3 6
==== 思考 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 循环),要求自己完成整个程序的编写并上机调试。完整程序如下:
#include
#include
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;
}
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
要点:这里用到了**上一行的结果**,所以 i 要从 2 开始、j 要从 1 开始;第 0 列和对角线上的 1 是递推的边界条件,必须先赋值。
==== 思考 7.9:数字电话加密 ====
某一军事机构采用数字电话传递军事情报数据,数据是 4 位整数。加密规则:**每位数字加上 5 除以 10,所得余数代替该位上的数字,然后再将第一位和第四位交换、第二位和第三位交换**,成为加密后的数字。
教材给的是带 ''<语句块>'' 占位的框架(并留下 ''retrun 0;'' 的拼写错误),要求分析算法并补全。完整程序:
#include
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;
}
g++ -Wall -o crypt crypt.cpp && echo 1234 | ./crypt
9876
核对规则:1234 各位加 5 取余得 6、7、8、9(即 6789),第一位与第四位交换得 9786,第二位与第三位交换得 **9876**,与程序输出一致。
==== 思考 7.10:通过结构体实现一个基本的图书馆管理系统 ====
该系统维护一个图书目录以及一个借书和还书事务的登记簿;使用这个系统可以增加图书的详细信息、记录借书/还书事务以及显示图书在库情况。教材把它拆成 4 步,并给出了 N-S 图(图 7.16、图 7.17)。
**(1)定义一个存储图书详细信息的结构体**,内容包括图书号、图书名、作者名、在馆图书数目:
struct book_st
{
int book_id; // 图书号
char book_nm[30]; // 图书名
char author[30]; // 作者名
int copies; // 在馆图书数目
};
**(2)定义一个存储借书/还书记录的结构体。** 其中借书/还书的日期也是一个结构体,此时需要**结构体的嵌套调用**:
struct date_st // 定义日期结构体
{
int month; // 定义月
int day; // 定义日
int year; // 定义年
};
struct tran_st // 定义借书/还书结构体
{
char tran_type; // 事件类型是借还是还
struct date_st tran_dt; // 定义 date_st 类型结构体
};
**(3)声明这两种结构体类型的变量**:为方便设计,假设要记录 4 本书的详细信息和 8 个事务。
struct book_st books[4];
struct tran_st trans[8];
**(4)针对系统设计的复杂性和软件工程模块化设计思想,把功能分解为 3 个模块**:模块 1 增加图书的详细信息;模块 2 记录借书/还书事务;模块 3 显示图书在馆情况。教材要求先设计一个操作菜单界面,为避免错误输入选项,采用**一个循环的形式**建立菜单界面,用 if 语句判断 choice 的值来确定所要执行的功能。在教材框架上补全后的完整程序:
#include
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;
}
要点回顾:结构体的成员可以是**另一种结构体**(''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】** 以下能正确定义一维数组的选项是 ______。
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";
答案:**B**。
* A 错在**初值个数超过数组长度**(5 个元素给了 6 个初值);
* C 错在**没有下标**,''a'' 只是一个 char 变量,装不下 3 个字符;
* D 错在**类型不匹配**,不能把字符串常量赋给 int 数组;
* B 合法:由初值的个数自动确定数组长度为 6。
**【试题 2】** 以下程序的输出结果是 ______。
int main()
{ int i,a[10];
for(i=9;i>=0;i--) a[i]=10-i;
cout<
A. 258 B. 741 C. 852 D. 369
答案:**C**。赋值关系是 ''a[i] = 10 - i'',所以 ''a[2]=8''、''a[5]=5''、''a[8]=2'',依次输出得到 852。
**【试题 3】** 以下能正确定义二维数组的是 ______。
A. int a[][3]; B. int a[][3] = {2*3};
C. int a[][3] = {}; D. int a[2][3] = {{1},{2},{3,4}};
答案:**C**(按教材的判分口径)。
* A 错在**行数没有给出、又没有初值**,编译器无法确定要分配多少空间;
* D 错在**初值的行数(3 行)超过了定义的行数(2 行)**;
* C 给出了列数 3 与空的初始化列表,合法;
* B 的 ''{2*3}'' 在现代 g++ 下其实也能编译通过(''2*3'' 是常量表达式,行数推为 1),教材是按「初始化列表中不应出现算式」的口径把它排除的——**在 Linux 上试着编译一下就知道了**,这也是理解「定义数组要用常量表达式」的一个好例子。
**【试题 4】** 有以下程序,运行后的输出结果是 ______。
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. 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】** 以下程序的输出结果是 ______。
int main()
{ int num=0;
while (num<=2)
{ num++; cout<
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,从键盘输入的值为 ______。
int main()
{ int s=0,a=0,n;
cin>>n;
do
{ s+=1; a=a-2; }
while(a!=n);
cout<
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】** 有以下程序,运行后的输出结果是 ______。
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<
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 定义成结构变量的是 ______。
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;
答案:**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<
#include
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;
}
教材要求仔细观察两点:**(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,必须先把指针转成字节指针:
cout << &a[1] - &a[0] << endl; // 输出 1(元素个数)
cout << (char *)&a[1] - (char *)&a[0] << endl; // 输出 4(字节数)
在 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 所指向的那个地址单元中的内容呢?** 那就要使用**间接存取运算符 ***。
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 自己的存放地址
教材强调了两个好习惯与一个提醒:**定义指针时同时将其初始化为空(NULL),这是非常重要的好习惯**(「指针变量乱指就会惹麻烦」);**要弄明白为什么要在字符串末尾补 ''\0''**;另外,8_14.cpp 中出现的 ''gets()'' 在现代 Linux + g++ 上已经**被删除**(它不检查缓冲区长度,是著名的不安全函数),要读一行输入请用 ''cin.getline()'' 或 ''fgets()''。
**相似例子:用指针求数组的最大值,并返回它的下标。** 把「指针即地址、*p 即内容、p−a 即下标」三件事一次用上:
#include
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;
}
最大值是 88,它在数组中的下标是 4
**再一个相似例子:值传递为什么换不了两个数。**(与前面函数部分呼应)
#include
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;
}
==== 9.3 用指针遍历数组(8_10.cpp 与 8_12.cpp)====
#include
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;
}
p=0x7ffd3b2a4c30 *p=1
p=0x7ffd3b2a4c34 *p=3
p=0x7ffd3b2a4c38 *p=5
p=0x7ffd3b2a4c3c *p=7
p=0x7ffd3b2a4c40 *p=9
教材在 32 位 + Visual C++ 6.0 下的输出形如 ''0012FF6C'';换成 64 位 Linux 后地址变成 0x7ffd… 这种十二位十六进制,**比较时只看差值**(相邻仍然相差 4)。
用 ''p - a'' 表示下标(8_12.cpp):
for (p = a; p < a + 5; p++)
cout << "下标为" << p - a << " 的数组单元: p=" << p << " *p=" << *p << endl;
===== 十、8.2 字符串与指针的运算 =====
**8_13.cpp:用指针变量来计算字符串的长度。**
#include
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;
}
abcdefgh
字符串 s 的长度为: 8
教材用图 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 行是极为精炼的语句,希望大家能学会**。
char *p = strp;
char *q = strq;
while (*p) // *p 为循环控制变量
* q++ = *p++; // 复制字符,并让 q 和 p 都加 1 指向下一处
* q = '\0'; // 在 strq 的末尾加字符串的结束符
教材的说明有两点:
* ''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 的实质):
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; // 用指针差求长度
}
**8_15.cpp:将一个字符串插入到另一个字符串中。** 教材说这个任务比较难,要求把 8_15.cpp 运行两遍、观察并记下输出结果,再粗略阅读程序、大体明白它的作用。
#include
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) 所指的地址单元
}
g++ -Wall -o insert insert.cpp && ./insert
abfg
cde
abcdefg
插入的过程(教材图 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 循环)。
#include
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;
}
123456789
改成 while 循环的写法:
char *p = &shuz[8];
while (p >= shuz) { cout << *p; p--; }
注意这里的循环条件是**指针之间的大小比较**:p 从 ''&shuz[8]'' 一路减到 ''shuz'',再减就越界了,所以判断条件必须写 ''p >= shuz''。
**相似例子:用两个指针判断回文串。**
#include
#include
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;
}
===== 十一、8.3 指针数组 =====
**以指针为单元的数组称为指针数组。** 教材图 8.12 中,指针数组 p 包含了 3 个数组单元 ''p[0]''、''p[1]''、''p[2]'',分别指向 3 处 ''&ar0[0]''、''&ar1[0]''、''&ar2[0]''。
按图 8.12 写出定义,并按图 8.13 理解「指针数组的元素及地址关系」:
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]
教材程序 8_17.cpp:
#include
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;
}
p[0]=0x7ffc8a5b3a40
p[1]=0x7ffc8a5b3a50
p[2]=0x7ffc8a5b3a60
ar0:012
ar1:123
ar0:234
(最后一行按数据应为 ''ar2:234'',教材原文的小标题写作 ''ar0'',属笔误。)教材还建议在 8_17.cpp 中加入下面这两句再运行看一看,用来确认图 8.13 画得对不对:
cout << &p[0][0] << "=" << &ar0[0] << endl;
cout << * &p[0][0] << "=" << p[0][0] << "=" << ar0[0] << endl;
**弄明白图 8.13 之后,你就会看出指针数组可以构成二维数组。** 教材的练习是:编写一个程序,用**指针数组**把下面的矩阵显示到屏幕上。
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
参考解答(每行一个一维数组,指针数组的元素各指向一行):
#include
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;
}
**要分清两个容易混淆的写法**:
int *p[3]; // 指针数组:3 个元素,每个都是 int *
int (*p)[3]; // 指向「含 3 个 int 的数组」的指针,即行指针
前者是「数组的元素是指针」,后者是「一个指针,指向一个数组」。''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 '' 已改为现代写法):
#include
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;
}
g++ -Wall -o maxp maxp.cpp && printf '3.1416\n2.7182\n' | ./maxp
x=3.1416
y=2.7182
两个数中较大的数为: 3.1416
教材的解题思路(归纳为 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):
#include
#include
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;
}
The old name is: xzhx
The new name is: xzcit
两点提醒:''strcpy'' **不检查目标数组是否够大**(目标比源短就会溢出),工程代码应改用 ''strncpy'' 或 C++ 的 ''std::string'';返回首地址的好处是可以**链式调用**,例如 ''strcpy(str3, strcpy(str1, str2));''。
**危险示例:不要返回局部变量的地址。**
float *bad() // 错误示范
{
float t = 3.14f;
return &t; // t 在函数返回时已被销毁,得到的是悬空指针
}
要返回指针,就让它指向**调用者提供的变量**(如 8_18.cpp 中的 x、y)、**静态变量**或**堆上的存储**。
==== 12.2 指向函数的指针(8.4.2)====
教材的解释很精炼:函数是由指令序列构成的,其代码存储在连成一片的内存单元中,这些代码中的**第一个代码所在的内存地址称为首地址**,首地址是函数的**入口地址**。主函数在调用子函数时,就是让程序转移到函数的入口地址去执行。所谓**指针指向函数,就是指针的值为函数的入口地址**。把数组与函数比较:指向数组的指针是让数组的首地址赋给指针变量;指向函数的指针是让函数的入口地址赋给指针变量。
教材的例子是先用类型定义标识符 ''typedef'' 定义一个指向函数的指针类型,该类型的名字是编程者自己起的,这里用 ''MenuFood''(菜单)作为类型名:
typedef void (*MenuFood)(); // 定义指向函数的指针类型
语句中在 typedef 后面的 ''void'' 表示 MenuFood 类型的指针所指向的函数**仅完成一系列操作,而没有返回值**。这种指向函数的指针类型定义好之后,就可以再用它定义具体的指针变量;本例是定义**带下标的变量**,即以 p 为名的指向函数的指针数组:
MenuFood P[] = {food1, food2, food3, food4};
其中 food1、food2、food3、food4 是 4 个函数,指针 ''p[0]'' 指向 food1,''p[1]'' 指向 food2,''p[2]'' 指向 food3,''p[3]'' 指向 food4。
**相似例子:把菜单做成函数指针数组**——正适合用在思考 7.10 的图书馆系统上:
#include
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;
}
(本页的页码范围到此为止,8.4 之后的内容见 [[程序设计基础:第8章]]。)
===== 十三、Linux 上机提示与常见错误 =====
**编译与调试:**
g++ -Wall -Wextra -g -o prog prog.cpp # 警告不要忽略,-g 便于用 gdb 单步
./prog
**地址与指针相关的注意事项:**
* 教材的地址示例(''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]'' |
===== 十四、知识结构导图 =====