第10章 指针与数组(5 指针和多维数组)

发布于 20 天前  58 次阅读


10.7 指针和多维数组

处理多维数组的函数要用到指针,,所以在使用这种函数之前,先要深入地学习指针。
Q1:指针和多维数组有什么关系?
int zippo[4][2];
然后数组名zippo是该数组元素的地址。在本例中,zippo的首元素是一个内含两个int值的数组,所以zippo是这个内含两个int值的数组的地址。
- 因为zippo是数组元素的首元素的地址,所以zippo的值和&zippo[0]的值相同。而zippo[0]本身是一个内含两个整数的数组,所以zippo[0]的值和它首元素(一个整数)的地址(即&zippo[0][0]的值)相同。
简而言之,zippo[0]是一个占用一个int大小对象的地址。而zippo是一个占用两个int大小对象的地址。由于这个整数和内存两个整数的数组都开始于同一个地址。所以zippo和zippo[0]的值相同。
- 给指针或地址加1,其值会增加对应类型大小的值。在这方面,zippo和zippo[0]不同,因为zippo指向的对象占用了两个int大小,而zippo[0]指向的对象只占用了一个int大小。
因此zippo+1和zippo[0]+1的值不同。
- 解引用一个指针(在指针前使用*运算符)或在数组名后使用带下标的[]运算符,得到引用对象代表的值,因为zippo[0]是该数组首元素(zippo[0][0])的地址,所以*(zippo[0]))表示存储在zippo[0][0]上的值,与此类似,*zippo代表数组元素(zippo[0])的值,但是zippo[0]本身是一个int类型值的地址。该值的地址是&zippo[0][0],所以*zippo就是&zippo[0][0].对两个表达式应用解引用运算符表明,**zippo与*&zippo[0][0]等价,这相当于zippo[0][0],即一个in类型的值。简单来说zippo是地址的地址,必须解引用两次才能获得原始值。地址的地址或指针的指针就是双重间接(double indirection)的例子
显然,增加数组维数会增加指针难度。
//zippo1.c      --zippo的相关信息
#include<stdio.h>
int main(void)
{
    int zippo[4][2]={{2,4},{6,8},{1,3},{5,7}};

    printf("zippo = %p,zippo+1 = %p\n",zippo,zippo+1);            
    printf("zippo[0]=%p,zippo[0]+1=%p\n",zippo[0],zippo[0]+1);
    printf("*zippo = %p,*zippo+1=%p\n",*zippo,*zippo+1);
    printf("zippo[0][0]=%d\n",zippo[0][0]);
    printf("*zippo[0]=%p\n",*zippo[0]);
    printf("**zippo=%d\n",**zippo);
    printf("zippo[2][1]=%d\n",zippo[2][1]);
    printf("*(*(zippo+2)+1)=%d\n",*(*(zippo+2)+1));

    return 0;
 } 

file

该输出显示了二维数组zippo的地址和一维数组zippo[0]的地址相同。它们的地址都是各自数组元素首元素的地址,因而与&zippo[0][0]的值也相同。
它们也有差别,int是4个字节,zippo[0]指向一个4字节的数据对象。zippo[0]加1,其值+4.数组名zippo是一个内含2个int类型值的数组的地址,所以zippo指向一个8字节的数据对象。因此zippo+1它所指向的地址+8字节。
该程序演示了zippo[0]和*zippo完全相同,实际上确实如此。然后对二维数组名解引用两次,得到存储在数组中的值。使用两个间接运算符*或者使用两对[]都能获得该值。
与zippo[2][1]等价的指针表示法是*(*(zippo+2)+1).

file

10.7.1 指向多维数组的指针

如何声明一个指针变量pz指向一个二维数组?
在编写处理类似zippo这样的二维数组时会用到这样的指针。
把指针声明为指向int的类型还不够。因为指向int只能与zippo[0]的类型匹配,说明该指针指向一个int类型的值。但是zippo是它的首元素的地址,该元素是一个内含两个int类型值的一维数组。因此,pz必须指向一个内含两个int类型的数组,而不是指向一个int类型值,其声明如下:
int (* pz)[2];      //pz指向一个内含两个int类型值的数组
以上代码把pz声明为指向一个数组的指针,该数组内含连个int值。为什么使用括号,因为[]的优先级高于*.
int *pax[2];    //pax是一个内含两个指针元素的数组,每个元素都指向int的指针
由于[]的优先级高,咸鱼pax结合,所以pax成为一个内含两个元素的指针。然后*表示pax数组内含两个指针。最后int表示pax数组中的指针都指向int类型的值。因此,这行代码声明了两个指向int的指针。而前面有圆括号的版本,*先于pz结合,因此声明的是一个指向数组(内含两个int类型的值)的值。

#include<stdio.h>
int main(void)
{
    int zippo[4][2]={{2,4},{6,8},{1,3},{5,7}};
    int (*pz)[2];
    pz = zippo;

    printf("pz = %p,pz+1 = %p\n",pz,pz+1);            
    printf("pz[0]=%p,pz[0]+1=%p\n",pz[0],pz[0]+1);
    printf("*pz = %p,*pz+1=%p\n",*pz,*pz+1);
    printf("pz[0][0]=%d\n",pz[0][0]);
    printf("*pz[0]=%d\n",*pz[0]);
    printf("**pz=%d\n",**pz);
    printf("pz[2][1]=%d\n",pz[2][1]);
    printf("*(*(pz+2)+1)=%d\n",*(*(pz+2)+1));

    return 0;
 } 

file

虽然pz是一个指针,不是数组名,但是也可以使用pz[2][1]这样的写法,可以用数组表示法或指针表示法来表示一个数组元素,即可以使用数组名,也可以使用指针名:
zippo[m][n] == *(*(pz+m)+n)
pz[m][n] == *(*(pz+m)+n)

10.7.2 指针的兼容性

指针之间的赋值比数值类型之间的赋值要严格。例如,不用类型转换就可以把int类型的值赋给double类型的变量,但是两个类型的指针不能这样做。
int n = 5;
double x;
int *p1 = &n;
double *pd = &x;
x = n;  //隐形类型转换
pd = p1;    //编译时错误
更复杂的类型也是如此。
int *pt;
int (*pa)[3];
int ar1[2][3];
int ar2[3][2];
int **p2;       //一个指向指针的指针
有如下语句
pt = &ar1[0][0];        //都是指向int的指针
pt = ar1[0];            //都是指向int的指针
pt = ar1;       //无效
pa = ar1;       //都是指向内含3个int类型元素组的指针
pa = ar2;   //无效
p2 = &pt;   //都是int类型指针
*pt = ar2[0];   //都是指向int类型的指针
p2 = ar2;   //无效
注意,以上无效的赋值表达式语句中涉及的两个指针都是指向不同的类型。例如:pt指向一个int类型值,而ar1指向一个内含3个int类型元素的数组。类似的,pa指向一个内含3个int类型元素的数组,所以它于ar1的类型兼容,但是ar2指向一个内含两个int类型元素的数组,所以pa与ar2不兼容。
变量p2是指向指针的指针,它指的指针指向int,而ar2是指向数组的指针,该数组内含两个int类型的元素。所以,p2和ar2的类型不同,不同把ar2赋给p2。但是,*p2是指向int的指针,与ar2[0]兼容。因为ar2[0]是指向该数组首元素(ar2[0][0])的指针,所以ar2[0]也是指向int的指针。
一般而言,多重解引用让人费解。例如:
int x =20;
const int y = 23;
int *p1 = &x;
const int *p2 = &y;
const int **pp2;
p1 = p2;            //不安全--把const指针赋给非const指针
p2 = p1;            //有效,把非const指针赋给const指针
pp2 = &p1;          //不安全,嵌套指针类型赋值
前面提到过,把const指针赋给非const指针不安全,因为这样可以使用新的指针改变const指针的数据。编译器在编译代码时,可能会给处警告,执行这样的代码是未定义的。但是把非const指针赋给const指针是没问题的,前提是只进行一级接引用:
p2 = p1;
但是进行两级解引用时,这样的赋值也不安全。
const int **pp2;
int *p1;
const int n = 13;
pp2 = &p1;      //有效,但是这导致const限定符失效(根据第一行,不能通过*pp2修改它所指向的内容)
*pp2 = &n;  //有效两个声明都是const,但是这将导致p1指向n (*pp2已被修改)
*p1 = 10;   //有效,但是这样将改变n的值。
如前所示,标准规定了通过非const指针更改const数据是未定义的。

Cconst与C++const
C和c++中的const的用法很相似,但是并不完全相同。区别之一是,C++允许在声明数组大小时使用const整数,而C却不允许。区别之二是,C++的指针检查更严格:
const int y;
const int *p2 = &y;
int *p1;
p1 = p2;    //C++中不允许这样做,但是C可能只给出警告
C++不允许把const指针赋给非const指针。而C则允许这样做,但是如果通过p1更改y,其行为是未定义的。

10.7.3 函数和多维数组

如果要编写处理二维数组的函数,首先要能正确的地理解指针才能写出声明函数的形参。在函数体中,通常采用数组表示法进行相关的操作。
编写一个处理二维数组的函数。一种方法是,利用for循环把处理一维数组的函数应用到二维数组的每一行。如下:
int junk[3][4]={{2,4,5,8},{3,5,6,9},{12,10,8,6}};
int i,j;
int total =0;
for(i=0;i<3;i++)
    total +=sum(junk[i],4);         //junk[i]是一维数组
#include<stdio.h>
int sum(int ar[],int hang);
int main(void)
{
    int a[3][3]={{1,2,3},{4,5,6},{7,8,9}};
    int i,j;
    int total = 0;
    for(i=0;i<3;i++)
        total +=sum(a[i],3);
    printf("%d",total);
    return 0;
 } 
 int sum(int ar[],int hang)
 {
    int j;
    int total=0;
    for(j=0;j<hang;j++)
        total+=ar[j];
    return total;
 }
    如果junk是二维数组,junk[i]就是一维数组,可将其视为一维数组的一行。这里sum()函数计算二维数组的每行总和,然后for循环把每行的总行加起来。
然而,这种方法无法记录行和列信息。用这种方法计算总和,行和列的信息并不重要。但如果每行代表一年,每列代表一月,就还需要一个函数计算某列的总和。该函数要知道行和列的信息,可以通过声明正确类型的形参变量来完成,以便函数能正确的传递数组。
数组junk是一个内含3个元素的数组,每个元素是内含4个int类型值的数组通过前面的讨论可知,这表明junk是一个指向数组的指针。可以这样声明函数的形参:
void somefunction(int (*pt)[4]);
另外,如果当且仅当pt是一个函数的形参时,咳哟这样声明:
void somefunction(int pt[][4]);
第一个方括号是空的。空的方括号表明pt是一个指针。
这样的变量稍后能以同样的方式作用于junk。
//  array2d.c       --处理二维数组
#include<stdio.h>
#define ROWS 3
#define COLS 4
void sum_rows(int ar[][COLS],int rows);
void sum_cols(int (*ar)[COLS],int rows);
int sum2d(int (*ar)[COLS],int rows);
int main(void) 
{
    int junk[ROWS][COLS]={
    {2,4,6,8},
    {3,5,7,9},
    {12,10,8,6}
    };

    sum_rows(junk,ROWS);
    sum_cols(junk,ROWS);
    printf("Sum of all elements = %d\n",sum2d(junk,ROWS));

    return 0;
}
void sum_rows(int ar[][COLS],int rows)
{
    int r;
    int c;
    int tot;

    for(r=0;r<rows;r++)
    {
        tot = 0;
        for(c = 0;c<COLS;c++)
            tot += ar[r][c];
        printf("row %d:sum = %d\n",r,tot);
    }
}

void sum_cols(int ar[][COLS],int rows)
{
    int r;
    int c;
    int tot;

    for(r=0;r<rows;r++)
    {
        tot = 0;
        for(c = 0;c<COLS;c++)
            tot += ar[r][c];
        printf("row %d:sum = %d\n",r,tot);
    }
}

int sum2d(int ar[][COLS],int rows)
{
    int r;
    int c;
    int tot = 0;

    for(r=0;r<rows;r++)
        for(c=0;c<COLS;c++)
            tot += ar[r][c];

    return tot;
}

file

程序清单中的程序把数组名junk(即指向数组首元素的指针,首元素是子数组)和符号常量ROWS(代表行数3)作为参数传递给函数。
每个函数都把ar视为内涵数组元素(每个元素都是内含4个int类型的数组)的数组。列数内置在函数体中,但是行数靠函数传递得到。如果传入函数的行数是12,那么函数要处理的是12×4的数组。因为rows 是元素个数,因为每个元素都是数组,或者视为一行,rows也可以看成是行数。
注意:ar和main()中的junk都使用数组表述法,因为ar和junk的类型相同,它们都是指向内含4个int类型值的数组的指针。
下面声明不正确
int sum2(int [][],int rows);
编译器会把数组表示法转换成指针表示法。例如,ar[1]转换成ar+1编译器对ar+1求值,要知道ar所指向的对象大小。
int sum2(int [][4],int rows);
表示ar指向一个内含4个int类型值的数组(ar指向的对象占16字节),所以ar+1的意思是该地址加上16字节。如果第二个方括号是空,编译器也不知道如何处理。
也可以在第一对方括号写上值,但是编译器会忽略该值。
int sum2(int ar[3][4],int rows);        //有效声明,但是3将会被忽略
与使用typedef相比,这种形式方便得更多:
typedef int arr4[4];        //arr4是一个内含4个int 的数组
typedef arr4 arr3×4[3];     //arr3×4是一个内含3个arr4的数组
int sum2(arr3×4 ar,int rows);       //与下相同
int sum2(int ar[3][4],int rows);
int sum2(int ar[][4],int rows); //标准形式
一般而言,声明一个指向N维数组的指针时,只能省略最左边方括号中的值:
int sum4d(int ar[][12][20][20][30],int rows);
因为第一队方括号只用于表明这是一个指针,其他的方括号则用于描述指针所指向数据对象的类型。
下面声明与之等价:
int sum4d(int (*ar)[12][20][30],int rows);
这里ar指向一个12×20×30的int数组。

擦肩而过的概率