C++ Primer Plus——第5章循环和关系表达式

purple 桐

已于 2023-05-13 12:56:07 修改

阅读量213

点赞数

文章标签： c++ 算法开发语言

于 2023-03-16 21:47:54 首次发布

本文链接：https://blog.csdn.net/weixin_42589774/article/details/129594035

版权

第5章循环和关系表达式

5.1 for循环
5.2 while循环
- 5.2.1 for与while
- 5.2.2 等待一段时间，编写延时循环
5.3 do while循环
5.4 基于范围的for循环
5.5 循环和文本输入
5.6 嵌套循环和二维数组
- 5.6.1 初始化二维数组
- 5.6.2 使用二维数组
5.7 总结

5.1 for循环

// 程序清单5.1 forloop.cpp--introducing the for loop
#include <iostream>

using namespace std;

int main(void)
{
    int i;
    // ++运算符——递增运算符，将操作数的值加1
    for (i = 0; i < 5; i++) {
        cout << "C++ knows loops." << endl;
    }
    cout << "C++ knows when to stop." << endl;

    return 0;
}

在这里插入图片描述

5.1.1 for循环的组成部分

for循环为执行重复的操作提供了循序渐进的步骤。for循环的组成部分完成下面这些步骤：
（1）循环的初始化：设置初始值（循环只执行一次初始化）
（2）循环测试：执行测试，决定循环体是否被执行（并不限制test-expression的值只能为真或假，可以使用任意表达式，C++将把结果强制转换为bool类型，值为0的表达式将被转换为false，导致循环结束；如果表达式的值为非零，则被强制转换为true，循环将继续进行）
（3）循环体：执行循环操作
（4）循环更新：更新用于测试的值（在每轮循环结束时执行，可以是任何有效的C++表达式）

初始化、测试和更新操作构成了控制部分，这些操作由括号括起。
其中每部分都是一个表达式，彼此由分号隔开。
控制部分后面的语句叫做循环体，只要测试表达式为true，它便被执行

for (initialization; test-expression; update-expression)
	body
	
for循环是入口条件循环。这意味着在每轮循环之前，都将计算测试表达式的值，当测试表达式为false时，将不会执行循环体。
C++语法将整个for看作一条语句——虽然循环体可以包含一条或多条语句。
for是一个C++关键字。

// 程序清单5.2 num_test.cpp--use numeric test in for loop
#include <iostream>

using namespace std;

int main(void)
{
    cout << "Enter the starting countdown value: ";
    int limit;
    cin >> limit;
    int i;
    for (i = limit; i; i--) {
        cout << "i = " << i << endl;
    }
    cout << "Done now that i = " << i << endl;

    return 0;
}

在这里插入图片描述

1、表达式和语句
for语句的控制部分使用3个表达式。

// 任何值或任何有效的值和运算符的组合都是表达式。
// 在C++中，每个表达式都有值。

22+27 //值为49
x = 20 // 值为20(C++将赋值表达式的值定义为左侧成员的值，赋值运算符从右向左结合)
// 当判定表达式的值时这种操作改变了内存中数据的值时，我们说表达式有副作用

// 只要加上分号，所有的表达式都可以成为语句，但不一定有编程意义

// 程序清单5.3 express.cpp--values of expressions
#include <iostream>

using namespace std;

int main(void)
{
    int x;

    cout << "The expression x = 100 has the value: " << (x = 100) << endl;
    cout << "Now x = " << x << endl;
    cout << "The expression x < 3 has the value: " << (x < 3) << endl;
    cout << "The expression x > 3 has the value: " << (x > 3) << endl;
    // cout在显示bool值之前将它们转换为int
    // 但cout.setf(ios::boolalpha)函数调用设置了一个标记，该标记命令cout显示true和false
    cout.setf(ios_base::boolalpha);
    cout << "The expression x < 3 has the value: " << (x < 3) << endl;
    cout << "The expression x > 3 has the value: " << (x > 3) << endl;

    return 0;
}

在这里插入图片描述
2、非表达式和语句
从语句中删除分号，并不一定能将它转换为表达式（例如：返回语句，声明语句，for语句）
3、修改规则

可以在for循环的初始化部分中声明变量，这种变量只存在于for语句中，当程序离开循环后，这种变量将消失
for (int i = 0; i < 5; i++)
for (for-init-statement condition; expression)
	statement

for-init-statement被视为一条语句，而语句有自己的分号。对于for-init-statement来说，它既可以是表达式语句，也可以是声明。这种句法规则用语句替换了后面跟分号的表达式。

5.1.2 回到for循环

// 程序清单5.4 formore.cpp--more looping with for
#include <iostream>

using namespace std;

const int ArSize = 16;

int main(void)
{
    long long factorials[ArSize];
    factorials[0] = factorials[1] = 1LL;
    for (int i = 2; i < ArSize; i++) {
        factorials[i] = i * factorials[i-1];
    }
    for (int i = 0; i < ArSize; i++) {
        cout << i << "! = " << factorials[i] << endl;
    }

    return 0;
}

在这里插入图片描述

5.1.3 修改步长

// 程序清单5.5 bigstep.cpp--count as directed
#include <iostream>

int main(void)
{
    using std::cout;
    using std::endl;
    using std::cin;

    cout << "Enter an integer: ";
    int by;
    cin >> by;
    cout << "Counting by " << by << "s:" << endl;
    for (int i = 0; i < 100; i = i + by) {
        cout << i << endl;
    }

    return 0;
}

在这里插入图片描述

5.1.4 使用for循环循环访问字符串

// 程序清单5.6 forstr1.cpp--using for with a string
#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    cout << "Enter a word: ";
    string word;
    cin >> word;

    for (int i = word.size() - 1; i >= 0; i--) {
        cout << word[i];
    }
    cout << endl;
    cout << "Bye." << endl;

    return 0;
}

在这里插入图片描述

5.1.5 递增运算符（++）和递减运算符（–）

前缀版本：++x；后缀版本：x++。两个版本对操作数的影响是一样的，但是影响的时间不同。

// 程序清单5.7 plus_one.cpp--the increment operator
#include <iostream>

using namespace std;

int main(void)
{
    int a = 20;
    int b = 20;

    // a++意味着使用a的当前值计算表达式，然后将a的值加1
    // ++b的意思是先将b的值加1，然后使用新的值来计算表达式
    // 不要在同一条语句对同一个值递增或递减多次——未定义行为
    cout << "a = " << a << "; b = " << b << endl;
    cout << "a++ = " << a++ << "; ++b = " << ++b << endl;
    cout << "a = " << a << "; b = " << b << endl;

    return 0;
}

在这里插入图片描述

5.1.6 副作用和顺序点

副作用：在计算表达式时对某些东西（如存储在变量中的值）进行了修改。
顺序点：程序执行过程中的一个点，在这里，进入下一步之前确保对所有的副作用都进行了评估。
在C++中，语句中的分号就是一个顺序点，这意味着程序处理下一条语句之前，赋值运算符、递增运算符和递减运算符执行的所有修改都必须完成。任何完整的表达式（不是另一个更大表达式的子表达式，例子：表达式语句中的表达式部分以及用作while循环中检测条件的表达式）末尾都是一个顺序点。

5.1.7 前缀格式和后缀格式

C++允许你针对类定义这些运算符，在这种情况下：
（1）前缀版本：将值加1，然后返回结果
（2）后缀版本：首先复制一个副本，将其加1，然后将复制的副本返回
对于内置类型，采用哪种格式不会有差别；但对于用户定义的类型，如果有用户定义的递增和递减运算符，则前缀格式的效率更高。

5.1.8 递增/递减运算符和指针

// 可以将递增运算符用于指针和基本变量
double arr[5] = {21.1, 32.8, 23.4, 45.2, 37.4};
double *pt = arr;
// 前缀递增、前缀递减和解除引用运算符的优先级相同，以从右向左的方式进行结合
// 后缀递增和后缀递减的优先级相同，但比前缀运算符的优先级高，这两个运算符以从左到右的方式进行结合
*++pt; // 先对pt自增，再取值，为32.8
++*pt; // 先取值，再自增，arr[1] = 33.8
(*pt)++; // 先取值，再自增，arr[1] = 34.8
*pt++; // 后缀运算符++的优先级更高，虽然先结合，但是*作用于自增前的pt，为34.8，pt指向arr[2]

5.1.9 组合赋值运算符

==表5.1==

5.1.10 复合语句（语句块）

循环体必须是一条语句。可在循环体中包含多条语句的方法：用两个花括号来构造一条复合语句（代码块），代码块由一对花括号和它们包含的语句组成，被视为一条语句，从而满足句法的要求。

// 程序清单5.8 block.cpp--use a block statement
#include <iostream>

using namespace std;

int main(void)
{
    cout << "The Amazing Accounto will sum and average five numbers for you." << endl;
    cout << "Please enter five values:" << endl;
    double number;
    double sum = 0.0;
    for (int i = 1; i <= 5; i++) {
        cout << "Value " << i << ": ";
        cin >> number;
        sum += number;
    }
    cout << "Five exquisits choices indeed! They sum to " << sum << endl;
    cout << "and average to " << sum / 5 << "." << endl;
    cout << "The Amazing Accounto bids you adieu!" << endl;

    return 0;
}

在这里插入图片描述
如果在语句块中定义一个新的变量，则仅当程序执行该语句块中的语句时，该变量才存在。执行完该语句块后，变量将被释放。如果在一个语句块中声明一个变量，而外部语句块中也有一个这种名称的变量，则在声明位置到内部语句结束的范围之内，新变量将隐藏旧变量；然后旧变量再次可见。

5.1.11 其他语法技巧——逗号运算符

逗号运算符允许将两个表达式放到C++句法只允许放一个表达式的地方。逗号并不总是逗号运算符，还有可能是分隔符（在声明语句中，将变量列表中相邻的名称分开）。

// 程序清单5.9 forstr2.cpp--reversing an array
#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    cout << "Enter a word: ";
    string word;
    cin >> word;

    char temp;
    int i, j;
    for (j = 0, i = word.size() - 1; j < i; --i, ++j) {
        temp = word[j];
        word[j] = word[i];
        word[i] = temp;
    }
    cout << word << endl << "Done" << endl;

    return 0;
}

在这里插入图片描述

// 逗号运算符是一个顺序点，它确保先计算第一个表达式，然后计算第二个表达式
i = 20, j = 20 * i; // i=20, j=40；表达式的值为40
// C++规定，逗号表达式的值是第二部分的值，在所有运算符中，逗号运算符的优先级是最低的
cats = 17, 240; // 被解释为(cata=17), 240
cats = (17, 240); // cats=240

5.1.12 关系表达式

关系运算符可用于字符和string类对象，不能用于C-风格字符串。
==表5.2==
关系运算符的优先级比算术运算符低。

5.1.13 赋值、比较和可能犯的错误

不要混淆等于运算符（==）与赋值运算符（=）

// 程序清单5.10 equal.cpp--equality vs assignment
#include <iostream>

using namespace std;

int main(void)
{
    int quizsores[10] = {20, 20, 20, 20, 20, 19, 20, 18, 20, 20};
    cout << "Doing it right:" << endl;
    int i;
    for (i = 0; quizsores[i] == 20; i++) {
        cout << "quiz " << i << " is a 20" << endl;
    }
    // cout << "Doing it dangerously wrong:" << endl; 
    // (1)将一个非零值赋给数组元素，因此表达式始终为非零，所以始终为true
    // (2)表达式将值赋给数组元素，实际上修改了数据
    // (3)由于测试表达式一直为true，因此程序在到达数组结尾后，仍不断修改数据。它把一个又一个20放入内存中
    // for (i = 0; quizsores[i] = 20; i++) {
    //     cout << "quiz " << i << " is a 20" << endl;
    // }

    return 0;
}

5.1.14 C-风格字符串的比较

// word是数组名
word == "mate";
// 数组名是数组的地址，用引号括起的字符串常量也是其地址
// 上面的关系表达式不是判断两个字符串是否相同，而是查看它们是否存储在相同的地址上
// 应使用C-风格字符串库中的strcmp()函数来比较
// 该函数接受两个字符串地址作为参数，参数可以是指针、字符串常量或字符数组名。
// 如果两个字符串相同，该函数将返回0；如果第一个字符串按系统排列顺序排在第二个字符串之前，则返回负数值；如果第一个字符串按系统排列顺序排在第二个字符串之后，则返回正数
// 在ASCII码中，所有大写字母的编码都比小写字母小
// C-风格字符串是通过结尾的空值字符定义的，而不是由其所在数组的长度定义的。这意味着两个字符串即使被存储在长度不同的数组中，也可能是相同的
char big[80] = "Daffy";
char little[6] = "Daffy";
int result = strcmp(big, little); // result=0

// 程序清单5.11 compstr1.cpp--comparing strings using arrays
#include <iostream>
#include <cstring>

using namespace std;

int main(void)
{
    char word[5] = "?ate";
    // 可以对字符变量使用递增运算符和递减运算符，因为char类型实际上是整型，因此这种操作实际上将修改存储在变量中的整数编码
    for (char ch = 'a'; strcmp(word, "mate"); ch++) {
        cout << word << endl;
        word[0] = ch;
    }
    cout << "After loop ends, word is " << word << endl;

    return 0;
}

在这里插入图片描述

5.1.15 比较string类字符串

类设计让你能够使用关系运算符进行比较，这之所以可行，是因为类函数重载了这些运算符。string类重载运算符的方式让你能够在下述条件下使用它：至少有一个操作数为string对象，另一个操作数可以是string对象，也可以是C风格字符串。

// 程序清单5.12 compstr2.cpp--comparing strings using arrays
#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string word = "?ate";
    for (char ch = 'a'; word != "mate"; ch++) {
        cout << word << endl;
        word[0] = ch;
    }
    cout << "After loop ends, word is " << word << endl;

    return 0;
}

在这里插入图片描述

5.2 while循环

while循环是没有初始化和更新部分的for循环，它只有测试条件和循环体：

while (test-condition)
	body

首先，程序计算圆括号内的测试条件表达式。如果表达式为true，则执行循环体中的语句。
循环体由一条语句或两个花括号定义的语句块组成。
执行完循环体后，程序返回测试条件，对它重新进行评估。
while循环也是一种入口条件循环。

// 程序清单5.13 while.cpp--introducing the while loop
#include <iostream>

using namespace std;

int main(void)
{
    const int ArSize = 20;
    char name[ArSize];
    cout << "Your first name, please: ";
    cin >> name;
    cout << "Here is your name, verticlized and ASCIIized:" << endl;
    int i = 0;
    while (name[i] != '\0') //while (name[i])，当name[i]为空值字符时，其编码将为0或false
    {
        // 要打印字符的ASCII码，必须通过强制类型转换将name[i]转换为整型
        cout << name[i] << ": " << int(name[i]) << endl;
        i++;
    }

    return 0;
}

在这里插入图片描述

5.2.1 for与while

for循环需要3个表达式，不过它们可以是空表达式（语句），只有两个分号是必须的。另外，省略for循环中的测试表达式时，测试结果将为true，循环将一直运行下去。
for与while存在的3个差别：
（1）在for循环中省略了测试条件时，将认为条件为true
（2）在for循环中，可使用初始化语句声明一个局部变量，但在while循环中不能这样做
（3）如果循环体中包括continue语句，情况稍有不同
在设计循环时，请记住下面几条指导原则：
（1）指定循环终止的条件
（2）在首次测试之前初始化条件
（3）在条件再次测试之前更新条件

// 分号结束语句，因此该分号将结束while循环。循环体为空语句，花括号中所有的代码永远不会被执行，循环不执行任何操作，是一个死循环
while (name[i] != '\0');
{
	cout << name[i] << endl;
	i++;
}

5.2.2 等待一段时间，编写延时循环

头文件ctime
clock()函数返回程序开始执行后所用的系统时间
定义了一个符号常量——CLOCKS_PER_SEC该常量等于每秒钟包含的系统时间单位数
将clock_t作为clock()返回类型的别名，这意味着可以将变量声明为clock_t类型，编译器将把它转换为long、unsigned int或适合系统的其他类型

// 程序清单5.14 waiting.cpp--using clock() in a time-delay loop
#include <iostream>
#include <ctime>

using namespace std;

int main(void)
{
    cout << "Enter the delay time, in seconds: ";
    float secs;
    cin >> secs;
    clock_t delay = secs * CLOCKS_PER_SEC;
    cout << "starting\a\n";
    clock_t start = clock();
    while (clock() - start < delay);
    cout << "done \a\n";

    return 0;
}

在这里插入图片描述

// 类型别名
// （1）使用预处理器
# define BYTE char
// 预处理器将在编译程序时用char替换所有的BYTE
// （2）使用关键字typedef，不会创建新类型，而只是为已有的类型建议一个新名称
typedef char byte;
typedef char * byte_pointer;
#define FLOAT_POINTER float*
FLOAT_POINTER pa, pb; // float *pa, pb; 只有pa是float*类型，pb是float类型

5.3 do while循环

do while是出口条件循环，这种循环将首先执行循环体，然后再判定测试表达式，决定是否应继续执行循环。
在这里插入图片描述

// 程序清单5.15 dowhile.cpp--exit-condition loop
#include <iostream>

using namespace std;

int main(void)
{
    int n;
    cout << "Enter numbers in the range 1-10 to find my favorite number" << endl;
    do {
        cin >> n;
    } while (n != 7);

    // cin >> n;
    // while (n != 7) {
    //     cin >> n;
    // }
    cout << "Yes, 7 is my favorite number." << endl;

    return 0;
}

在这里插入图片描述

5.4 基于范围的for循环

C++11新增了一种循环：基于范围的for循环。

double prices[5] = {4.99, 10.99, 6.87, 7.99, 8.49};
for (double x : prices)
	cout << x << endl;
// 符号&表明x是一个引用变量，这种声明让接下来的代码能够修改数组的内容，而第一种语法不能
for (double &x : prices)
	x = x * 0.8

5.5 循环和文本输入

5.5.1 使用原始的cin进行输入

选择某个特殊字符——哨兵字符，将其作为停止标记。

// 程序清单5.16 textin1.cpp--reading chars with a while loop
#include <iostream>

using namespace std;

int main(void)
{
    char ch;
    int count = 0;
    cout << "Enter characters; enter # to quit:" << endl;
    // cin忽略空格和换行符，输入中的空格没有被回显，也不会包括在计数内
    // 发送给cin的输入被缓冲。
    // 只有在用户按下回车键后，他输入的内容才会被发送给程序。这就是在运行该程序时，可以在#后面输入字符的原因。
    // 按下回车键后，整个字符序列将被发送给程序，但程序在遇到#字符后将结束对输入的处理
    cin >> ch;
    while (ch != '#') {
        cout << ch;
        ++count;
        cin >> ch;
    }
    cout << endl << count << " characters read" << endl;

    return 0;
}

在这里插入图片描述

5.5.2 使用cin.get(char)进行补救

// 程序清单5.17 textin2.cpp--using cin.get(char)
#include <iostream>

using namespace std;

int main(void)
{
    char ch;
    int count = 0;
    cout << "Enter characters; enter # to quit:" << endl;
    // 成员函数cin.get(ch)读取输入中的下一个字符（即使是空格），并将其赋给变量ch
    // 头文件iostream将cin.get(ch)的参数声明为引用类型，因此该函数可以修改其参数的值
    cin.get(ch);
    while (ch != '#') {
        cout << ch;
        ++count;
        cin.get(ch);
    }
    cout << endl << count << " characters read" << endl;

    return 0;
}

注：该程序若输入空行，将显示空行，且不影响后续输入。
在这里插入图片描述

5.5.3 使用哪一个cin.get()

函数重载允许创建多个同名函数，条件是他们的参数列表不同。

char name[ArSize];
cin.get(name, ArSize);
cin.get();
char ch;
cin.get(ch);

5.5.4 文件尾条件

如果输入来自于文件，则可以使用一种功能更强大的技术——检测文件尾（EOF）。C++输入工具和操作系统协同工作，来检测文件尾并将这种信息告知程序。

（1）很多系统都支持重定向，允许用文件替换键盘输入。
假设在Windows中有一个名为gofish.exe的可执行程序和一个名为fishtale的文本文件，则可以在命令提示符模式下输入下面的命令：
gofish <fishstale
程序将从fishtale文件（而不是键盘）获取输入。<符号是Unix和Windows命令提示符模式的重定向运算符。

（2）很多操作系统都允许通过键盘来模拟文件尾条件（Ctrl+D、Ctrl+Z和Enter、Ctrl+Z等）

检测到EOF后，cin将两位（eofbit和failbit）都设置为1。
可以通过成员函数eof()来查看eofbit是否被设置；如果检测到EOF，则cin.eof()将返回bool值true，否则返回false。
成员函数fail()同理。
注意，eof()和fail()方法报告最近读取的结果；它们在事后报告，而不是预先报告。因此应将cin.eof()或cin.fail()测试放在读取后。

// 程序清单5.18 textin3.cpp--reading chars to end of file
#include <iostream>

using namespace std;

int main(void)
{
    char ch;
    int count = 0;
    cout << "Enter characters; enter # to quit:" << endl;
    cin.get(ch);
    while (cin.fail() == false) {
        cout << ch;
        ++count;
        cin.get(ch);
    }
    // 这里再Windows7系统上运行该程序，因此可以按下Ctrl+Z和回车键来模拟EOF条件
    // 在Unix和类Unix系统中，用户应按下Ctrl+Z组合键将程序挂起，而命令fg恢复执行程序
    
    // istream类提供了一个可以将istream对象转换为bool值的函数
    // 当cin出现在需要bool值的地方时，该转换函数将被调用，如果读取成功将转换为true，否则为false
    // 这比!cin.faile()或!cin.eof()更通用，因为它可以检测到其他失败原因，如磁盘故障
    // while (cin.get(ch))
    // 程序必须首先调用cin.get(ch)。如果成功，则将值放入ch中。
    // 然后，程序获得函数调用的返回值，即cin。
    // 接下来，程序对cin进行bool转换，如果输入成功，则结果为true，否则为false
    cout << endl << count << " characters read" << endl;

    return 0;
}

在这里插入图片描述
1、EOF结束输入
cin方法检测到EOF时，将设置cin对象中一个指示EOF条件的标记。设置这个标记后，cin将不读取输入，再次调用cin也不管用。cin.clear()方法可能清除EOF标记，使输入继续进行。但在有些系统中，按Ctrl+Z实际上将结束输入和输出，而cin.clear()将无法恢复输入和输出。
2、常见的字符输入做法

（1）
cin.get(ch);
while (cin.fail() == false) {
	cin.get(ch);
}
（2）
cin.get(ch);
while (!cin.fail()) {
	cin.get(ch);
}
（3）
while (cin.get(ch)) {

}

5.5.5 另一个cin.get()版本

不接受任何参数的cin.get()成员函数返回输入中的下一个字符
ch = cin.get(); // 将字符编码作为int值返回，cin.get(ch)返回一个对象，而不是读取的字符
可以使用cout.put()函数来显示字符
cout.put(ch); // 其参数为char，不是int；使用显式强制类型装换可使用int参数cout.put(char(ch))

// 当cin.get()函数到达EOF时，将没有可返回的字符
// cin.get()将返回一个用符号常量EOF表示的特殊值
// 该常量是在头文件iostream中定义的
// EOF值必须不同于任何有效的字符值，以便程序不会将EOF与常规字符混淆，通常，EOF被定义为值-1，因为没有ASCII码为-1的字符

int ch;
ch = cin.get();
while (ch != EOF) {
	cout.put(ch);
	++count;
	ch = cin.get();
}

// 由于EOF表示的不是有效字符编码，因此可能不与char类型兼容。
// 例如，在某些系统中，char类型是没有符号的，因此char变量不可能为EOF值（-1）
// 由于这种原因，如果使用cin.get()并测试EOF，则必须将返回值赋给int变量，而不是char变量
// 如果将ch的类型声明为int，而不是char，则必须在显示ch时将其强制转换为char类型

// 程序清单5.19 textin4.cpp--reading chars with cin.get()
#include <iostream>

using namespace std;

int main(void)
{
    int ch;
    int count = 0;
    cout << "Enter characters; enter # to quit:" << endl;

    while ((ch = cin.get()) != EOF) {
        cout.put(char(ch));
        ++count;
    }
    cout << endl << count << " characters read" << endl;

    return 0;
}

在这里插入图片描述
cin.get(char)函数在到达EOF时，不会将一个特殊值赋给ch。事实上，在这种情况下，它不会将任何值赋给ch。ch不会被用来存储非char值。

5.6 嵌套循环和二维数组

二维数组更像是一个表格——既有数据行又有数据列。C++没有提供二维数组类型，但用户可以创建每个元素本身都是数组的数组。
在这里插入图片描述

for (int row = 0; row < 4; row++) {
	for (int col = 0; col < 5; col++) {
		cout << maxtemps[row][col] << "\t";
	}
	cout << endl;
}

5.6.1 初始化二维数组

// 初始化由一系列逗号分隔的一维数组初始化（用花括号括起）组成
int maxtemps[4][5] = 
{
	{96, 100, 87, 101, 105},
	{96, 98, 91, 107, 104},
	{97, 101, 93, 108, 107},
	{98, 103, 95, 109, 108}
}

5.6.2 使用二维数组

// 程序清单5.20 nested.cpp--nested loops and 2-D array
#include <iostream>

using namespace std;

int main(void)
{
    const int Cities = 5;
    const int Years = 4;
    // 将一个指针数组初始化为一组字符串常量，将cities声明为一个char指针数组
    // 这使得每个元素都是一个char指针，可被初始化为一个字符串的地址
    // 也可使用char cities[Cities][25]或string cities[Cities]
    const char *cities[Cities] = 
    {
        "Gribble City",
        "Gribbletown",
        "New Gribble",
        "San Gribble",
        "Gribble Vista"
    };

    int maxtemps[Years][Cities] = 
    {
        {96, 100, 87, 101, 105},
        {96, 98, 91, 107, 104},
        {97, 101, 93, 108, 107},
        {98, 103, 95, 109, 108}
    };

    cout << "Maximum temperatures for 2008 - 2011" << endl;
    for (int city = 0; city < Cities; ++city) {
        cout << cities[city] << ":\t";
        for(int year = 0; year < Years; ++year) {
            cout << maxtemps[year][city] << "\t";
        }
        cout << endl;
    }

    return 0;
}