智能程序设计（C语言）

int a[10];
*a = 7;      /* 将 7 存储在a[0]中 */
*(a+1) = 12; /* 将 12 存储在a[1]中 */

/* 原始版本 */
for (p = &a[0]; p < &a[N]; p++)
    sum += *p;
/* 简化版本 */
for (p = a; p < a + N; p++)
    sum += *p;

while (*a != 0)
    a++; /*** 错误的 ***/

p = a;
while (*p != 0)
    p++;

假设a声明如下, 把数组名 a 当指针用的示例:

一般情况, a+i与&a[i]相同, 都表示指向数组a中的元素i的指针.

此外, *(a+i)等价于a[i], 两者都代表元素i本身.

数组名称可以用作指针这一事实使得编写遍历数组的循环变得更加容易.

尽管数组名可以用作指针, 但不能为数组名赋新值.

试图让数组名指向其他地方是错误的:

可以将a复制到指针变量中, 然后更改指针变量:

#include <stdio.h>
#define N 6

int main(void)
{
  int a[N] = {2, 4, 6, 8, 10, 12};
  int sum = 0;

  for (int *p = a; p < a + N; p++)
    sum += *p;

  for (int i = 0; i < N; i++)
    printf("i=%d: a[%d]=%d, *(a+%d)=%d\n",
           i, i, a[i], i, *(a + i));

  printf("sum = %d\n", sum);
  printf("a = %p, &a[0] = %p\n",
         (void *)a, (void *)&a[0]);
  printf("a + 1 = %p, &a[1] = %p\n",
         (void *)(a + 1), (void *)&a[1]);
  return 0;
}

• 数组名 a 在表达式中就是指向首元素的指针: a 与 &a[0] 的值相同

• a[i] 是 *(a + i) 的语法糖——下标运算的本质就是"地址 + 偏移再解引用"

• a + N 是最后一个元素之后的地址: 可以取、可以比较, 但不能解引用

• a 是数组名不是指针变量, 不能被赋值; 要移动就复制到 int *p

#define N 10
int find_largest(int a[], int n)
{
    int max;

    max = a[0];
    for (int i = 1; i < n; i++)
        if (a[i] > max)
            max = a[i];
    return max;
}

int main(void) {
    int b[N] = {0}, largest;
    ...
    /* 此调用导致将指向b的第一个元素的指针赋值给a, 数组本身不会被复制. */
    largest = find_largest(b, N); /* 调用find_largest */
    ...
}

int find_largest(const int a[], int n)
{
    …
}

数组名传递给函数时, 总是被视为指针. 例子:

把数组型形式参数视为指针会产生许多重要的结果:

• 结果1: 普通变量传给函数时, 其值被复制, 对相应参数的任何更改都不会影响变量. 相反, 用作参数的数组是可能被改变的.

比如下面这个函数, 把数组每个元素清零:

void store_zeros(int a[], int n)
{
    int i;

    for (i = 0; i < n; i++)
        a[i] = 0;
}

为了表明数组参数不会被修改, 我们可以在它的声明中包含单词const:

编译器会检查find_largest函数体没有对a中元素进行赋值.

对 b[5] ~ b[14] 调用 find_largest 的示例:

int b[20] = {0};
...
largest = find_largest(&b[5], 10);

考虑将以下数组的所有元素初始化为0的问题：

int a[NUM_ROWS][NUM_COLS];

/* 方法1: 使用嵌套的for循环来进行二维数组的初始化 */
for (int row = 0; row < NUM_ROWS; row++)
    for (int col = 0; col < NUM_COLS; col++)
        a[row][col] = 0;

/* 方法2: 将a视为一维的整型数组, 单个循环进行初始化 */
int * p;
…
for (p = &a[0][0]; p <= &a[NUM_ROWS-1][NUM_COLS-1]; p++)
    *p = 0;

之前学过: C 以行优先顺序存储二维数组.

r行的数组的布局:

p 一开始指向第 0 行第 0 列 (\(a[0][0]\)), 不断自增 p 就能挨个访问每个元素。

严格说, 把二维数组当一维扁平遍历依赖实现 (标准不保证可移植), 了解思路即可——正规写法是嵌套循环，或用后面介绍的行指针（指向数组的指针）。

该方法会损害程序的可读性, 对老的编译器可能产生效率提升.

对于许多现代编译器, 速度优势通常不存在.

/* 将p初始化为指向数组a中第i行的元素0 */
p = &a[i][0];

/* 可简化为 */
p = a[i];

int a[NUM_ROWS][NUM_COLS], *p, i;
…
for (p = a[i]; p < a[i] + NUM_COLS; p++)
    *p = 0;

int a[NUM_ROWS][NUM_COLS] = {0};
...
largest = find_largest(a[i], NUM_COLS);

指针变量p也可用于处理二维数组的一行中的元素.

为访问第i行的元素:

对于任何二维数组a, 表达式a[i]是指向第i行第一个元素的指针.

为了解原理, 回顾一下:

• 表达式\(a[i]\)等价于\(*(a + i)\).

• 因此&a[i][0]就是第i行第0个元素的地址.

• 再由&*a[i]等价于\(a[i]\), 可得&a[i][0] = &(*(a[i] + 0)) = &*a[i] = \(a[i]\).

对数组a的第i行清零的循环:

由于a[i]是指向第i行第一个元素的指针, 可将它传给处理一维数组的函数——一维数组函数也能处理二维数组的行.

用find_largest求二维数组a第i行的最大值:

/* 对数组a的第i列清零的循环 */
int a[NUM_ROWS][NUM_COLS],  (*p)[NUM_COLS], i;
…
for (p = &a[0]; p < &a[NUM_ROWS]; p++)
    (*p)[i] = 0;

int a[NUM_ROWS][NUM_COLS];

处理二维数组一列的元素:

int (*p)[NUM_COLS];把p声明为指向长度为NUM_COLS的整型数组的指针

• (*p)括号是必需的, 若无括号则编译器将p看作指针数组, 而不是指向数组的指针

• p++把p移到下一行的开始位置

• 在(*p)[i]中, *p代表a的一整行, (*p)[i]选中该行的第i列的元素

• (*p)[i]中的括号是必要的, 无括号编译器会将*p[i]解释为*(p[i])

任何数组的名称都可以用作指针, 不管它有多少维, 但需要注意.

a不是指向a[0][0]的指针, 它是指向a[0]的指针.

C将a视为一维数组, 其元素是一维数组.

当用作指针时, a 的类型为int (*)[NUM_COLS] （指向长度为NUM_COLS的整数数组的指针）.