1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char* ;
一般使用:
1. int main() 2. { 3. char ch = 'w'; 4. char *pc = &ch; 5. *pc = 'w'; 6. return 0; 7. }
还有一种使用方式如下：
1. int main() 2. { 3. const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？ 4. printf("%s\n", pstr); 5. return 0; 6. }
代码 const char* pstr = "hello bit.";
特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是本质是把字符串 hello
bit. 首字符的地址放到了pstr中。
上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。
那就有可这样的面试题：
1. #include <stdio.h> 2. int main() 3. { 4. char str1[] = "hello bit."; 5. char str2[] = "hello bit."; 6. const char* str3 = "hello bit."; 7. const char* str4 = "hello bit."; 8. if (str1 == str2) 9. printf("str1 and str2 are same\n"); 10. else 11. printf("str1 and str2 are not same\n"); 12. if (str3 == str4) 13. printf("str3 and str4 are same\n"); 14. else 15. printf("str3 and str4 are not same\n"); 16. return 0; 17. }
这里最终输出的是：
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化，不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。
2. 指针数组
在《初步拿捏C指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。
这里我们再复习一下，下面指针数组是什么意思？
1. int* arr1[10]; //整形指针的数组 2. char *arr2[4]; //一级字符指针的数组 3. char **arr3[5];//二级字符指针的数组
3. 数组指针
3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？
1. int *p1[10]; 2. int (*p2)[10]; 3. //p1, p2分别是什么？
解释：
1. int (*p)[10]; 2. //解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个 3. 指针，指向一个数组，叫数组指针。 4. //这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
3.2 &数组名VS数组名
对于下面的数组：
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们看一段代码：
1. #include <stdio.h> 2. int main() 3. { 4. int arr[10] = { 0 }; 5. printf("%p\n", arr); 6. printf("%p\n", &arr); 7. return 0; 8. }
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：
1. #include <stdio.h> 2. int main() 3. { 4. int arr[10] = { 0 }; 5. printf("arr = %p\n", arr); 6. printf("&arr= %p\n", &arr); 7. printf("arr+1 = %p\n", arr+1); 8. printf("&arr+1= %p\n", &arr+1); 9. return 0; 10. }
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40
3.3 数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：
1. #include <stdio.h> 2. int main() 3. { 4. int arr[10] = {1,2,3,4,5,6,7,8,9,0}; 5. int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p 6. //但是我们一般很少这样写代码 7. return 0; 8. }
一个数组指针的使用：
1. #include <stdio.h> 2. void print_arr1(int arr[3][5], int row, int col) 3. { 4. int i = 0; 5. int j = 0; 6. for (i = 0; i < row; i++) 7. { 8. for (j = 0; j < col; j++) 9. { 10. printf("%d ", arr[i][j]); 11. } 12. printf("\n"); 13. } 14. } 15. void print_arr2(int(*arr)[5], int row, int col) 16. { 17. int i = 0; 18. int j = 0; 19. for (i = 0; i < row; i++) 20. { 21. for (j = 0; j < col; j++) 22. { 23. printf("%d ", arr[i][j]); 24. } 25. printf("\n"); 26. } 27. } 28. int main() 29. { 30. int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 }; 31. print_arr1(arr, 3, 5); 32. //数组名arr，表示首元素的地址 33. //但是二维数组的首元素是二维数组的第一行 34. //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址 35. //可以数组指针来接收 36. print_arr2(arr, 3, 5); 37. return 0; 38. }
4. 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
4.1 一维数组传参
1. #include <stdio.h> 2. void test(int arr[])//ok 3. {} 4. void test(int arr[10])//ok 5. {} 6. void test(int* arr)//ok 7. {} 8. void test2(int* arr[20])//ok 9. {} 10. void test2(int** arr)//ok 11. {} 12. int main() 13. { 14. int arr[10] = { 0 }; 15. int* arr2[20] = { 0 }; 16. test(arr); 17. test2(arr2); 18. }
4.2 二维数组传参
1. void test(int arr[3][5])//ok 2. {} 3. void test(int arr[][])//error 4. {} 5. void test(int arr[][5])//ok 6. {} 7. //总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。 8. //因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。 9. //这样才方便运算。 10. void test(int* arr)//ok 11. {} 12. void test(int* arr[5])//指针数组 13. {} 14. void test(int(*arr)[5])//ok 15. {} 16. void test(int** arr)//ok 17. {} 18. int main() 19. { 20. int arr[3][5] = { 0 }; 21. test(arr); 22. }
