记住公式*(*(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; 
  12. } 
 
  
声明指向多维数组的指针
 
  
声明的时候一定要告知编译器指向的数据的类型是什么！数组名表示法和指针表示法是可以通用的
 
  
记住
 
  
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; 
  13. } 
 
  
指针的兼容性
 
  
 
 
  
 
  
  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的值 
  14. } 
 
  
函数和多维数组
 
  
 
 
  
 
  
  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.  
  23. void sum_rows(int ar[][COLS],int rows){ 
  24.     int r; 
  25.     int c; 
  26.     int tot; 
  27.  
  28.     for(r=0;r<rows;r++){//首先固定row，求得的值是一行的和 
  29.         tot = 0; 
  30.         for(c=0;c<COLS;c++){ 
  31.             tot += ar[r][c]; 
  32.         } 
  33.         printf("row %d:sum = %d\n",r,tot); 
  34.     } 
  35. } 
  36.  
  37. void sum_cols(int ar[][COLS],int rows){ 
  38.     int r; 
  39.     int c; 
  40.     int tot; 
  41.  
  42.     for(c=0;c<COLS;c++){ 
  43.         tot = 0; 
  44.         for(r=0;r<rows;r++){ 
  45.             tot += ar[r][c]; 
  46.         } 
  47.         printf("col %d:sum = %d\n",c,tot); 
  48.     } 
  49. } 
  50.  
  51. int sum2d(int ar[][COLS],int rows){ 
  52.     int r; 
  53.     int c; 
  54.     int tot = 0; 
  55.  
  56.     for(r=0;r<rows;r++){ 
  57.         for(c=0;c<COLS;c++){ 
  58.             tot += ar[r][c]; 
  59.         } 
  60.     } 
  61.     return tot; 
  62. }