智能程序设计（C语言）

到目前为止的变量都是标量:

int x = 5; /* 一个变量存一个值 */

• 保存单一数据项

C 还支持聚合:

int a[10]; /* 一个名字存一组值 */

• 存储一组一组的数值

• 聚合类型有两种: 数组和结构体

int a[10];
│  │ │
│  │ └─ 长度: 10 个元素 (下标 0~9)
│  └──── 数组名: 这批数据共用的名字
└─────── 元素类型: 每个元素都是 int

#define N 10
…
int a[N];

声明一个数组, 需要定两件事: 类型和数量

元素可以是任何类型; 长度必须是(整数)常量表达式

可以用宏定义数组长度——改长度只改一处

a[0] = 1;
printf("%d\n", a[5]);
++a[i];

for (i = 0; i < N; i++) {
  a[i] = 0;             /* ① 清零 */
}

for (i = 0; i < N; i++) {
  scanf("%d", &a[i]);   /* ② 读入 */
}

for (i = 0; i < N; i++) {
  sum += a[i];          /* ③ 求和 */
}

a[i] 是左值, 可以像普通变量一样用——上面三种操作都合法

• 对数组的常见操作, 几乎都是"循环 + 下标"的这三个模式:

  • ① 清零 / 赋初值、② 逐个读入、③ 累加 / 统计

a[i + j * 10] = 0;  /* 先算 i + j*10 */
a[i * W + j];       /* 第 i 行第 j 列 */
a[n - 1 - i];       /* 倒数第 i 个 */

下标里可以写任意整数表达式: 先算出值, 再当下标用

• a[i * W + j]——把二维网格平铺成一维; 后面的二维数组, 底层就是这个

• a[n - 1 - i]——倒数第 i 个; 待会儿的数列反向、挑战里的回文数都靠它

i = 0;
while (i < N) {
  a[i++] = 0;      /* ① 下标顺带改了 i */
}

i = 0;
while (i < N) {
  a[i] = b[i++];   /*** ② 危险! ***/
}

for (i = 0; i < N; i++) {
  a[i] = b[i];     /* ③ 安全写法 */
}

下标里也能写 i++——副作用要小心:

• ① 只读写 i 一次, 行为确定

• ② 读 i 和改 i 不分先后, 导致未定义的行为

• ③ 把自增移出下标——for 的第三段专门干这个

常规初始化

int a[10] = {1, 2, 3};
/* 前三个 1 2 3, 其余自动补 0 */

int a[10] = {0};
/* 全 0 初始化的惯用写法 */

int a[] = {1, 2, 3};
/* 长度省略: 编译器数出来 = 3 */

• 初始化式比数组短 → 其余元素自动赋 0

• 初始化式为空或超长都非法

• 给了初始化式, 长度可以省略——由编译器计算

• 大数组只改少数元素, 一个个列出来冗长易错——指定初始化式来救场

指定初始化式 (C99)

int a[15] = {[2] = 29, [9] = 7};
/* [2]=29 和 [9]=7, 其余自动补 0 */

int a[15] = {[9] = 7, [2] = 29};
/* 顺序无关, 效果一样 */

int b[] = {[23] = 5};
/* 省略长度: 从最大指示符推出 24 */

• C99 的指定初始化式: [下标] = 值, 只初始化想改的元素

• 括号中的数字叫指示符, 取值 0 ~ n-1

• 省略长度时, 编译器从最大指示符推出长度

/* 0~15 转十六进制字符 */
#include <stdio.h>

int main(void)
{
  const char hex_chars[] =
    {'0','1','2','3','4','5','6','7','8','9',
     'A','B','C','D','E','F'};

  int n;
  printf("输入 0~15: ");
  scanf("%d", &n);
  printf("%c\n", hex_chars[n]);   /* 下标查表 */
  return 0;
}

做完了几个案例, 学一个新工具: 用数组查表

• 声明时加 const, 数组变成只读——编译器帮你看住, 想改直接报错

• 查表: 值当下标, 取出对应字符——repdigit 的标志数组是"记", 这张表是"取"

• 下一题进制转换的 16 进制输出、后面生命游戏的图案打印, 都要靠它

/* 进制转换(含 16 进制): 反复取余存下标, const 查表输出 */
#include <stdio.h>

int main(void)
{
  const char digit[] =
    {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
  int n, base, digits[32];
  int len = 0, i;

  printf("输入十进制数和进制: ");
  scanf("%d%d", &n, &base);

  do {
    digits[len++] = n % base;
    n /= base;
  } while (n > 0);

  for (i = len - 1; i >= 0; i--) {
    printf("%c", digit[digits[i]]);   /* 查表输出 */
  }
  printf("\n");
  return 0;
}

• 短除法的每一步余数先后顺序是反的——存进数组再逆序输出, 正好接上 reverse 的写法

• len 既是"下一个空位"又是"已存个数"——数组配合计数变量的经典搭档

• 输出用的就是前面学的 const 查表——数字 0~15 变字符

/* 回文数: 数字拆进数组, 首尾对称比较 */
#include <stdio.h>

int main(void)
{
  long n, m;
  int digits[20], len = 0, i;

  printf("输入一个整数: ");
  scanf("%ld", &n);

  m = n;                       /* 拆数字, 个位在前 */
  do {
    digits[len++] = m % 10;
    m /= 10;
  } while (m > 0);

  for (i = 0; i < len / 2; i++)      /* 只比到一半 */ {
    if (digits[i] != digits[len - 1 - i]) {
      printf("%ld 不是回文数\n", n);
      return 0;
    }
  }
  printf("%ld 是回文数\n", n);
  return 0;
}

• 首尾对称: 第 i 位 vs 第 len-1-i 位——下标关系的推演是这题的灵魂

• 发现不对称可以提前 return, 不用比完

• 只比到 len/2, 奇数长度中间那位不用比

#define NUM_RATES 5
#define NUM_YEARS 5

double balance[NUM_RATES];
for (int r = 0; r < NUM_RATES; r++) {
  balance[r] = 100.0;
  for (int y = 1; y <= NUM_YEARS; y++) {
    balance[r] = balance[r] * (1 + 0.01 * (r + 3));   /* 每年复利 */
    printf("%8.2f", balance[r]);
  }
  printf("\n");
}

本金 100 元, 5 种利率各存 5 年, 列出每年的余额:

关键: 第 y+1 年的余额依赖第 y 年——每一年的中间值都要存下来

• 数组的第三种用途: 除了"存一批数据"和"批量处理", 还能保存中间状态