wdg_014.txt

c编程宝典,详细介绍有关c的资料

指针变量带下标, 如p[i]与*(p+i)等价。 
    假若:      p=a+5; 
则p[2]就相当于*(p+2), 由于p指向a[5], 所以p[2]就相当于a[7]。而p[-3]就相 
当于*(p-3), 它表示a[2]。 

    2.2. 指向二维数组的指针 
    2.2.1. 二维数组元素的地址 
    为了说明问题, 我们定义以下二维数组: 
     int a[3][4]={{0,1,2,3}, {4,5,6,7}, {8,9,10,11}}; 
a为二维数组名, 此数组有3行4列, 共12个元素。但也可这样来理解, 数组a由三 
个元素组成: a[0], a[1], a[2]。而它匀中每个元素又是一个一维数组, 且都含 
有4个元素 (相当于4列),  例如, a[0]所代表的一维数组所包含的 4 个元素为 
a[0][0], a[0][1], a[0][2], a[0][3]。如图5.所示: 
        ┏━━━━┓    ┏━┳━┳━┳━┓ 
  a─→ ┃  a[0]  ┃─→┃0 ┃1 ┃2 ┃3 ┃ 
        ┣━━━━┫    ┣━╋━╋━╋━┫ 
        ┃  a[1]  ┃─→┃4 ┃5 ┃6 ┃7 ┃ 
        ┣━━━━┫    ┣━╋━╋━╋━┫ 
        ┃  a[2]  ┃─→┃8 ┃9 ┃10┃11┃ 
        ┗━━━━┛    ┗━┻━┻━┻━┛ 
                    图5. 
    但从二维数组的角度来看, a代表二维数组的首地址,  当然也可看成是二维 
数组第0行的首地址。a+1就代表第1行的首地址, a+2就代表第2行的首地址。如 
果此二维数组的首地址为1000, 由于第0行有4个整型元素, 所以a+1为1008, a+2 
也就为1016。如图6.所示 
                            a[3][4] 
                   a    ┏━┳━┳━┳━┓ 
              (1000)─→┃0 ┃1 ┃2 ┃3 ┃ 
                   a+1  ┣━╋━╋━╋━┫ 
              (1008)─→┃4 ┃5 ┃6 ┃7 ┃ 
                   a+2  ┣━╋━╋━╋━┫ 
              (1016)─→┃8 ┃9 ┃10┃11┃ 
                        ┗━┻━┻━┻━┛ 
                              图6. 
    既然我们把a[0], a[1], a[2]看成是一维数组名, 可以认为它们分别代表它 
们所对应的数组的首地址, 也就是讲,  a[0]代表第 0 行中第 0 列元素的地址, 
即&a[0][0], a[1]是第1行中第0列元素的地址, 即&a[1][0], 根据地址运算规则, 
a[0]+1即代表第0行第1列元素的地址, 即&a[0][1], 一般而言, a[i]+j即代表第 
i行第j列元素的地址, 即&a[i][j]。 
    另外, 在二维数组中, 我们还可用指针的形式来表示各元素的地址。如前所 
述, a[0]与*(a+0)等价, a[1]与*(a+1)等价, 因此a[i]+j就与*(a+i)+j等价, 它 
表示数组元素a[i][j]的地址。 
    因此, 二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j),  它们都与 
a[i][j]等价, 或者还可写成(*(a+i))[j]。 
    另外, 要补充说明一下, 如果你编写一个程序输出打印a和*a,  你可发现它 
们的值是相同的, 这是为什么呢? 我们可这样来理解: 首先, 为了说明问题, 我 
们把二维数组人为地看成由三个数组元素a[0], a[1], a[2]组成, 将a[0], a[1], 
a[2]看成是数组名它们又分别是由4个元素组成的一维数组。因此, a表示数组第 
0行的地址, 而*a即为a[0], 它是数组名, 当然还是地址, 它就是数组第0 行第0 
列元素的地址。 

    2.2.2 指向一个由n个元素所组成的数组指针 
    在Turbo C中, 可定义如下的指针变量: 
      int (*p)[3]; 
    指针p为指向一个由3个元素所组成的整型数组指针。在定义中, 圆括号是不 
能少的, 否则它是指针数组, 这将在后面介绍。这种数组的指针不同于前面介绍 
的整型指针, 当整型指针指向一个整型数组的元素时, 进行指针(地址)加1运算, 
表示指向数组的下一个元素, 此时地址值增加了2(因为放大因子为2), 而如上所 
定义的指向一个由3个元素组成的数组指针, 进行地址加1运算时, 其地址值增加 
了6(放大因子为2x3=6), 这种数组指针在Turbo C中用得较少,  但在处理二维数 
组时, 还是很方便的。例如: 
          int a[3][4], (*p)[4]; 
          p=a; 
    开始时p指向二维数组第0行, 当进行p+1运算时, 根据地址运算规则,  此时 
放大因子为4x2=8, 所以此时正好指向二维数组的第1行。和二维数组元素地址计 
算的规则一样, *p+1指向a[0][1], *(p+i)+j则指向数组元素a[i][j]。 
     例1 
     int a[3] [4]={ 
     {1,3,5,7}, 
     {9,11,13,15}, 
     {17,19,21,23} 
    }; 
    main() 
    { 
         int i,(*b)[4]; 
           b=a+1;                  /* b指向二维数组的第1行, 此时*b[0]或 
                                     **b是a[1][0] */ 
         for(i=1;i<=4;b=b[0]+2,i++)/* 修改b的指向, 每次增加2 */ 
           printf("%d\t",*b[0]); 
         printf("\n"); 
         for (i=0; i<2; i++) { 
           b=a+i;                  /* 修改b的指向,  每次跳过二维数组的 
                                      一行 */ 
           printf("%d\t",*(b[i]+1)); 
        } 
         printf ("\n"); 
     } 
    程序运行结果如下: 
     9    13   17   21 
     3    11   19 

    3. 字符指针 
    我们已经知道, 字符串常量是由双引号括起来的字符序列, 例如: 
          "a string" 
就是一个字符串常量, 该字符串中因为字符a后面还有一个空格字符, 所以它由8 
个字符序列组成。在程序中如出现字符串常量C 编译程序就给字符串常量按排一 
存贮区域, 这个区域是静态的, 在整个程序运行的过程中始终占用, 平时所讲的 
字符串常量的长度是指该字符串的字符个数, 但在按排存贮区域时, C 编译程序 
还自动给该字符串序列的末尾加上一个空字符'\0', 用来标志字符串的结束, 因 
此一个字符串常量所占的存贮区域的字节数总比它的字符个数多一个字节。 
    Turbo C中操作一个字符串常量的方法有: 
    (1). 把字符串常量存放在一个字符数组之中, 例如: 
          char s[]="a string"; 
数组s共有9个元素所组成, 其中s[8]中的内容是'\0'。实际上, 在字符数组定义 
的过程中, 编译程序直接把字符串复写到数组中, 即对数组s初始化。 
    (2). 用字符指针指向字符串, 然后通过字符指针来访问字符串存贮区域。 
当字符串常量在表达式中出现时, 根据数组的类型转换规则, 它被转换成字符指 
针。因此, 若我们定义了一字符指针cp: 
     char *cp; 
于是可用: 
     cp="a string"; 
使cp指向字符串常量中的第0号字符a, 如图7.所示。 
            cp 
        ┏━━━┓     ┏━┳━┳━┳━┳━┳━┳━┳━┳━┓ 
        ┃    ─╂─→ ┃a ┃  ┃s ┃t ┃r ┃i ┃n ┃g ┃\0┃ 
        ┗━━━┛     ┗━┻━┻━┻━┻━┻━┻━┻━┻━┛ 
                              图7. 
以后我们可通过cp来访问这一存贮区域, 如*cp或cp[0]就是字符a,  而cp[i]或 
*(cp+i)就相当于字符串的第i号字符, 但企图通过指针来修改字符串常量的行为 
是没有意义的。 

    4. 指针数组 
    因为指针是变量, 因此可设想用指向同一数据类型的指针来构成一个数组, 
这就是指针数组。数组中的每个元素都是指针变量, 根据数组的定义, 指针数组 
中每个元素都为指向同一数据类型的指针。指针数组的定义格式为: 
     类型标识 *数组名[整型常量表达式]; 
    例如: 
       int *a[10]; 
定义了一个指针数组, 数组中的每个元素都是指向整型量的指针, 该数组由10个 
元素组成, 即a[0], a[1], a[2], ..., a[9], 它们均为指针变量。a为该指针数 
组名, 和数组一样, a是常量, 不能对它进行增量运算。a为指针数组元素a[0]的 
地址, a+i为a[i]的地址, *a就是a[0], *(a+i)就是a[i]。 
    为什么要定义和使用指针数组呢? 主要是由于指针数组对处理字符串提供了 
更大的方便和灵活, 使用二维数组对处理长度不等的正文效率低, 而指针数组由 
于其中每个元素都为指针变量, 因此通过地址运算来操作正文行是十分方便的。 
    指针数组和一般数组一样, 允许指针数组在定义时初始化, 但由于指针数组 
的每个元素是指针变量, 它只能存放地址, 所以对指向字符串的指针数组在说明 
赋初值时, 是把存放字符串的首地址赋给指针数组的对应元素, 例如下面是一个 
书写函数month_name(n), 此函数返回一个指向包含第n月名字的字符指针( 关于 
函数, 第6节将专门介绍)。 
    例2: 打印1月至12月的月名: 
     char *month_name(int n) 
     { 
          static char *name[]={ 
               "Illegal month", 
               "January", 
               "February", 
               "March", 
               "April", 
               "May", 
               "June", 
               "July", 
               "August", 
               "September", 
               "October", 
               "November", 
               "December" 
          }; 
          return((n<1||n>12)?name[0]:name[n]); 
     } 
     main() 
     { 
          int i; 
          for(i=0; i<13; i++) 
               printf("%s\n", month_name(i)); 
     }