学c51的基础 9 《 指针、结构、联合和枚举 》.txt

单片机的c51用法,基础篇,谁用的着谁下载

    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));

     }