目录

程序设计基础_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]

教材给出的三条结论:

这个规律用一个小程序验证最直观:

#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;
}

在 64 位 Linux 上,同一行内相邻元素的地址相差 4(int 占 4 个字节),而 &data[0]、data 的数值都与 &data[0][0] 一致——这正是「数组名就是首地址」的证据。

二、程序 7_11.cpp:二维数组的典型应用

教材的例子是「计算每年降水总量和 6 年的年平均降水总量」,思路是对二维数组中的每个元素进行相加,为此可以用两重计数型循环:

#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;
}

编译运行:

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 <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;
}

运行结果(总分依次为 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

判断当年是否为闰年的两个条件(教材原文):

写成 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 <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;
}

教材专门解释了第 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 <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;
}

前 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 <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;
}
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 <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;
}
input ten character: abcdefghij
jihgfedcba

注意:这种逐个字符的写法不会自动补 \0,所以只能用循环逐字符输出、不能整体输出 a;另外 cin » a[i] 会跳过空格与回车,若要连空格一起读进来,应改用 cin.get(a[i])。

(2)把字符数组作为字符串进行整体输入/输出:在 cin 中只给出字符数组名,在 cout 中也只给出字符数组名。

【任务 7.12】将两个字符串输入字符数组,并把两个数组中的字符串输出(程序 7_16.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;
}
Good Luck
a1=Good,a2=Luck

教材的程序说明有两条,非常重要:

char a[10];
cin.getline(a, 10);

输入 C C++ C#,则这个含有空格的字符数组 a 的内容为 C C++ C#(getline 会自动补上 \0)。

相似例子:输入一行文字,统计字母、数字、空格、其他字符的个数。

#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;
}
请输入一行文字:
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 <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;
}
数组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 <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;
}
1 4
2 5
3 6

思考 7.8:打印杨辉三角形

教材指出:由于图形是二维的,所以采用二维数组,用 a[i][j] 表示第 i 行、第 j 列的元素;为配合数组的定义规则,设三角形的首行为第 0 行、最左边的一列为第 0 列。于是

教材只给了 C 语言描述(两个 for 循环),要求自己完成整个程序的编写并上机调试。完整程序如下:

#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;
}
     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 <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;
}
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 <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;
}

要点回顾:结构体的成员可以是另一种结构体(trans[i].trandt.month 是二级访问);结构数组的每个元素都是同一种结构体;flag 控制「是否继续」的循环,正是教材 N-S 图中 for(i=0;i<4 && flag=='y'; i++) 的写法;图书号用 books[i].bookid = i + 1; 自动加 1。

思考 7.11:去掉 while 循环会怎样

教材问:把 while() 循环去掉,输入 1、2、3、4 以外的选项,观察有什么不同。

答案:菜单只会出现一次。while (choice != 4) 的作用是「只要不选择离开就重新显示菜单」,去掉之后程序执行完一次选择就走到 return 0 结束;输入非法选项(例如 5)时,任何 if 分支都不匹配,程序什么都不做便退出。这正是教材强调「为避免错误输入选项,采用一个循环的形式建立菜单界面」的原因。

六、7.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】 以下程序的输出结果是 。

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;
}

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 的 {23} 在现代 g++ 下其实也能编译通过(23 是常量表达式,行数推为 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[1][i];
  return 0;
}

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,从键盘输入的值为 。

int main()
{ int s=0,a=0,n;
  cin>>n;
  do
  { s+=1; a=a-2; }
  while(a!=n);
  cout<<s<<endl;
  return 0;
}

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 定义成结构变量的是 。

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 个小程序挨个跑一遍:

程序 改动的关键语句 运行结果与结论
81.cpp | cout«a[0]«endl; 等 5 条 | 输出 1 3 5 7 9——数组元素的值 | | 82.cpp cout«&a[0]«endl; 等 5 条 输出 0012FF6C 一类的地址——符号 & 是取地址运算符