记住公式*(*(ptrArray+i)+j) == ptrArray[i][j]

  1. #include<stdio.h> 
  2.  
  3. int main(void){ 
  4.     int zippo[4][2] = {{2,4},{6,8},{1,3},{5,7}}; 
  5.  
  6.     printf("zippo=%p,zippo+1=%p",zippo,zippo+1);//zippo指向的数据类型是包含两个int类型的数组,所以类型大小是8字节,所以地址实际 
  7.                                                 //增长了8个字节 
  8.     printf("zippo[0]=%p,zippo[0]+1=%p",zippo[0],zippo[0]+1);//zippo[0]指向的数据类型是int类型,所以类型大小是4字节,所以地址实际 
  9.                                                 //增长了4个字节 
  10.  
  11.     return 0; 

声明指向多维数组的指针

声明的时候一定要告知编译器指向的数据的类型是什么!数组名表示法和指针表示法是可以通用的

记住

zippo[m][n] == *(*(zippo+m)+n)

p[m][n] == *(*(p+m)+n)

 

  1. #include<stdio.h> 
  2.  
  3. int main(void){ 
  4.     int zippo[4][2] = {{2,4},{6,8},{1,3},{5,7}}; 
  5.     int (*p)[2] = zippo;//必须要有括号,否则int *p [2]声明的是一个数组,该数组含有两个指针,这两个指针指向int类型 
  6.  
  7.     printf("zippo=%p,zippo+1=%p",p,p+1);//p指向的数据类型是包含两个int类型的数组,所以类型大小是8字节,所以地址实际 
  8.                                                 //增长了8个字节 
  9.     printf("zippo[0]=%p,zippo[0]+1=%p",p[0],p[0]+1);//p[0]指向的数据类型是int类型,所以类型大小是4字节,所以地址实际 
  10.                                                 //增长了4个字节 
  11.  
  12.     return 0; 

指针的兼容性

 

  1. #include<stdio.h> 
  2.  
  3. int main(void){ 
  4.     int *p1; 
  5.     const int *p2; 
  6.     const int **pp2; 
  7.     p1 = p2;//编译错误,把const指针赋予非const指针 
  8.     p2 = p1;//可以把非const指针赋予const指针 
  9.     pp2 = &p1;//编译错误,不能进行多层运算,因为如果可以的话,就会有如下内容 
  10.  
  11.     const int n = 13; 
  12.     *pp2 = &n;//两者都是const,但这样也会令p1指向n 
  13.     *p1 = 10;//合法,但是这样讲改变n的值 

函数和多维数组

 

  1. #include<stdio.h> 
  2. #define ROWS 3 
  3. #define COLS 4 
  4.  
  5. void sum_rows(int ar[][COLS],int rows);//列数信息必不可少,因为它表明指针指向的数据类型,但是行数可以没有,有也自动忽略掉 
  6. void sum_cols(int [][COLS],int);//一般声明N维数组的指针时,最左边的方括号可以留空之外,其他都需要填写 
  7. int sum2d(int (*ar)[COLS],int rows); 
  8.  
  9. int main(void){ 
  10.     int junk[ROWS][COLS] = { 
  11.         {2,4,6,8}, 
  12.         {3,5,7,9}, 
  13.         {12,10,8,6} 
  14.     }; 
  15.      
  16.     sum_rows(junk,ROWS);//列是函数体内定义的,行数是靠函数传递得到的 
  17.     sum_cols(junk,ROWS); 
  18.  
  19.     printf("Sum of all elements = %d\n",sum2d(junk,ROWS)); 
  20.     return 0; 
  21.  
  22. void sum_rows(int ar[][COLS],int rows){ 
  23.     int r; 
  24.     int c; 
  25.     int tot; 
  26.  
  27.     for(r=0;r<rows;r++){//首先固定row,求得的值是一行的和 
  28.         tot = 0; 
  29.         for(c=0;c<COLS;c++){ 
  30.             tot += ar[r][c]; 
  31.         } 
  32.         printf("row %d:sum = %d\n",r,tot); 
  33.     } 
  34.  
  35. void sum_cols(int ar[][COLS],int rows){ 
  36.     int r; 
  37.     int c; 
  38.     int tot; 
  39.  
  40.     for(c=0;c<COLS;c++){ 
  41.         tot = 0; 
  42.         for(r=0;r<rows;r++){ 
  43.             tot += ar[r][c]; 
  44.         } 
  45.         printf("col %d:sum = %d\n",c,tot); 
  46.     } 
  47.  
  48. int sum2d(int ar[][COLS],int rows){ 
  49.     int r; 
  50.     int c; 
  51.     int tot = 0; 
  52.  
  53.     for(r=0;r<rows;r++){ 
  54.         for(c=0;c<COLS;c++){ 
  55.             tot += ar[r][c]; 
  56.         } 
  57.     } 
  58.     return tot;