加载中...

6.10 再说泛化

另举一个泛化的例子：想象一下，你需要一个可以打印任意长度的乘法表，而不仅仅是6×6的表。你可以为printMultTable添加一个参数：

  1. void printMultTable (int high) {
  2.     int i = 1;
  3.     while (i <= high) {
  4.         printMultiples (i);
  5.         i = i + 1;
  6.     }
  7. }

我用参数high替代6。如果我用参数值7调用printMultTable，我将得到输出：

  1. 1 2 3 4 5 6
  2. 2 4 6 8 10 12
  3. 3 6 9 12 15 18
  4. 4 8 12 16 20 24
  5. 5 10 15 20 25 30
  6. 6 12 18 24 30 36
  7. 7 14 21 28 35 42

一切很好，除了一点：我可能想让这个表变为方阵（行数和列数一样）。这意味着我需要为printMultiples添加另一个参数来指定表的列数。

絮叨几句，我也把这个参数命名为high，说明了不同函数可以有相同名字的参数（如同局部变量）：

  1. void printMultiples (int n, int high) {
  2.     int i = 1;
  3.     while (i <= high) {
  4.         cout << n*i << " ";
  5.         i = i + 1;
  6.     }
  7.     cout << endl;
  8. }
  10. void printMultTable (int high) {
  11.     int i = 1;
  12.     while (i <= high) {
  13.         printMultiples (i, high);
  14.         i = i + 1;
  15.     }
  16. }

注意，当我添加一个新的参数，我必须改变函数的第一行（即接口或原型），同时必须修改printMultTable中调用函数的地方。正如所料，这段程序生成了一个7×7的方阵：

  1. 1 2 3 4 5 6 7
  2. 2 4 6 8 10 12 14
  3. 3 6 9 12 15 18 21
  4. 4 8 12 16 20 24 28
  5. 5 10 15 20 25 30 35
  6. 6 12 18 24 30 36 42
  7. 7 14 21 28 35 42 49

当你适当的泛化一个函数以后，你常常会发现程序的输出结果有一些意外的性质。比如，你可能注意到了，乘法表示对称的，因为ab=ba，所以表中所有的项都出现了两次。你可以只打印半张表以省墨。将

  1. printMultiples (i, high);

改为

  1. printMultiples (i, i);

你将得到输出：

  1. 1
  2. 2 4
  3. 3 6 9
  4. 4 8 12 16
  5. 5 10 15 20 25
  6. 6 12 18 24 30 36
  7. 7 14 21 28 35 42 49

至于其工作原理，就留给你分析了。

还没有评论.