C补习---------＞第六天，二级指针、指针和数组的关系、位置排序

1，二级指针：

二维数组？---》数组的数组
二级指针？---》指针的指针

概念：二级指针存储的是一级指针的地址
（定义意味着有空间
  有空间就会有地址）
  
  格式：
       定义一级指针的格式：
       存储类型  数据类型 * 指针变量名;
       
       定义二级指针的格式：
       存储类型  数据类型 **指针变量名;
       分析：
            存储类型：二级指针自身的存储类型
            数据类型**：二级指针的数据类型
            数据类型*：二级指针所指向的类型
            指针变量名：见名知义
            
--------------------------------------------------------
总结：
（1）什么时候需要定义一个二级指针出来？----》当需要该一级指针的值时
（2）如何确定指针的类型？
-----》去掉[变量名] ,剩余的就是该指针自身的类型
     eg:
         int *p; int *
         int **pp; int **
（3）如何确定指针所指向的类型？
----》去掉[* 指针变量名] ，剩余的就是该指针所指向的类型
（4）如何分析一个指针一次性访问空间的大小？
----》依赖于所指向的类型
    char **pp; pp一次性访问空间的大小为4个
    char *p; p一次性访问的空间为1个
    int ****pppp;pppp一次性可以访问空间为4个
    

1. #include <stdio.h>

3. int main(int argc, const char *argv[])

4. {

5. int a = 90;

6. int b = 78;

7. int *p = &a;

8. printf("*p = %d\n",*p);

9. //*p = 56;

10. //p = &b;

11. int **pp = &p;

12. *pp = &b;

13. printf("*p = %d\n",*p);

15. return 0;

16. }

-----------------------------------------------------------------------------------------------------

指针和数组的结合：
指针和一维数组的关系：

指针的算术运算：(+ - * / % ++ --)

假设以p和q为例（注意：p和q是同类型的指针变量）
p + N:代表p向地址增大方向移动N个数据类型的大小（p + sizeof(数据类型) * N）
p - N:代表p向地址减小方向移动N个数据类型的大小（p - sizeof(数据类型) * N）
p++:代表p向地址增大方向移动1个数据类型的大小（p + sizeof(数据类型) * 1）
p--:代表p向地址减小方向移动1个数据类型的大小（p - sizeof(数据类型) * 1）
p-q:代表两个指针之间相隔元素的个数（ p - q / sizeof(数据类型)）

1. #include <stdio.h>

3. int main(int argc, const char *argv[])

4. {

5. //定义三个指针变量

6. int *p;

7. short *q;

8. char *s;

9. int *r = p+4;

12. printf("r-p = %d\n",r-p);

13. /*

15. p++;

16. printf("p = %p\n",p);

17. printf("p = %p\t p + 1 = %p\n",p,p+3);

18. printf("q = %p\t s + 1 = %p\n",q,q+1);

19. printf("s = %p\t s + 1 = %p\n",s,s+1);

20. */

21. return 0;

22. }

p++和p+1的区别：
p++《===》 p = p+1;因此，p++会引起指针指向的改变
p+1不会引起指针指向的改变

数组名：
（1）作为数组名，可以代表整个数组
（2）也可以代表数组的首地址

打印输出数组元素的方式：
arr[i]  <===> *(arr+i)  <===> *(p+i) <===> *(p++)  <===> p[i] <===> i[arr]  <===> i[p]

1. ​

2. #include <stdio.h>

4. int main(int argc, const char *argv[])

5. {

6. int arr[5] = {1,2,3,4,5};

7. printf("sizeof(arr) = %d\n",sizeof(arr));

8. //定义一个指针，指向该一维数组的首元素

9. int *p = arr;

11. //printf("arr = %p\n",arr);

12. //printf("&arr[0] = %p\n",&arr[0]);

13. int i;

14. for(i=0;i<5;i++)

15. {

16. //printf("%d ",arr[i]);

17. //printf("%d ",*(arr+i));

18. //printf("%d ",*(p+i));

19. //printf("%d ",*(p++));

20. //printf("%d ",p[i]);

21. //printf("%d ",i[arr]);

22. printf("%d ",i[p]);

23. }

24. printf("\n");

25. return 0;

26. }

28. ​

分析：可以使用p[i]这种方式来遍历数组的原因是：编译器会自动将p[i]编译成*(p+i)  

总结：
对于数组名：arr[i] 
对于指针：*(p+i) / *(p++)  

练习： 
（1）从键盘获得一个字符串，利用指针实现求该字符串中空格的个数

1. ​

2. #include <stdio.h>

5. #define N 20

6. int main(int argc, const char *argv[])

7. {

8. //定义一个字符数组

9. char str[N] = {'\0'};

10. //定义一个字符指针指向该数组的首元素

11. char *p = str;

12. printf("请输入一个字符串:\n");

13. gets(p);

15. int count = 0;

16. //遍历该字符串

17. while(*p != '\0')

18. {

19. if(' ' == *p)

20. {

21. count++;

22. }

23. p++;

24. }

25. printf("count = %d\n",count);

26. return 0;

27. }

29. ​

（2）利用指针实现冒泡（改变指针指向/ 不改变指针指向）

1. #include <stdio.h>

3. #define N 5

4. int main(int argc, const char *argv[])

5. {

6. //利用指针实现排序

7. int arr[N] = {0};

8. //定义一个整形指针变量指向该数组首元素

9. int *p = arr;

11. printf("请输入:\n");

12. int i,j;

13. for(i=0;i<N;i++)

14. {

15. //scanf("%d",&arr[i]);

16. scanf("%d",p+i);

17. }

19. printf("排序之前为: \n");

20. for(i=0;i<N;i++)

21. {

22. //printf("% ",arr[i]);

23. printf("%d ",*(p+i));

24. }

25. printf("\n");

28. for(i=0;i<N-1;i++)

29. {

30. p = arr;//让p重新指向首元素

31. for(j=0;j<N-1-i;j++)

32. {

33. if(*p > *(p+1))

34. {

35. int temp;

36. temp = *p;

37. *p = *(p+1);

38. *(p+1) = temp;

39. }

40. p++;

41. }

42. }

43. printf("排序之后为: \n");

44. p = arr;

45. for(i=0;i<N;i++)

46. {

47. //printf("% ",arr[i]);

48. printf("%d ",*(p+i));

49. }

50. printf("\n");

55. return 0;

56. }

冒泡排序：从左至右，两两依次进行比较  

          注意：冒泡按照数据找位置
选择排序：
         假设有N个数：
         第一趟：找出最大的数，将该数与位置为0的数字进行交换
         第二趟：从总个数减1的人数中，再找出最大的时钟与位置为1的数字进行交换。。
         。。。。。。。。。。。。
         

         注意：选择按照位置找数据

1. #include <stdio.h>

3. #define M 5

4. int main(int argc, const char *argv[])

5. {

6. int arr[M] = {0};

8. int i;

9. for(i=0;i<M;i++)

10. {

11. scanf("%d",&arr[i]);

12. }

14. int j;

15. //int index;

16. //选择排序

17. for(i=0;i<M-1;i++)

18. {

19. //index = i;

20. for(j=i+1;j<M;j++)

21. {

22. /*if(arr[index] > arr[j])

23. {

24. index = j;

25. }

26. */

27. if(arr[i] > arr[j])

28. {

29. int temp;

30. temp = arr[i];

31. arr[i] = arr[j];

32. arr[j] = temp;

33. }

34. }

35. /*

36. //交换

37. int temp;

38. temp = arr[i];

39. arr[i] = arr[index];

40. arr[index] = temp;

41. */

42. }

44. printf("排序之后为:\n");

45. for(i=0;i<M;i++)

46. {

47. printf("%d ",arr[i]);

48. }

49. putchar('\n');

50. return 0;

51. }

作业：
1，指针实现，定义一个字符串，实现字符串的倒置  "break" ---> "kaerb"

1. #include<stdio.h>

2. #include<string.h>

4. #define M 5

5. int main(int argc, const char *argv[])

6. {

7. //指针实现，字符串的倒置

8. char arr[M] = {'\0'};

9. printf("请输入字符串:\n");

11. //定义指针

12. char *p = arr; // p = &arr[0]

13. gets(p);

15. //使用strlen来测出arr数组的有效字节

16. int l;

17. l = strlen(arr);

19. //p(首地址) + l -1 就是末地址

20. p = p + l - 1;

22. int i;

23. for(i = 0;i < M;i++)

24. {

25. printf("%c",*(p-i));

27. }

28. putchar('\n');

30. return 0;

31. }

2，利用指针实现strcat功能

1. #include<stdio.h>

2. #include<string.h>

4. #define M 15

5. #define N 20

6. char *mystrcat(char *p,char*q,int n)

7. {

8. if(NULL == p || NULL == q)

9. {

10. printf("NULL_ERROR!\n");

11. return NULL;

12. }

14. while(*p)

15. {

16. p++;

17. }

19. //n代表连接arr2的n位

20. while(n--)

21. {

22. *p++ = *q++;

23. }

25. *p = '\0';

26. return q;

27. }

28. int main(int argc, const char *argv[])

29. {

30. //使用指针实现strcat的前n位

31. char arr1[M] = {'\0'};

32. char arr2[N] = {'\0'};

33. printf("请输入两个字符串:\n");

35. //gets输入字符串

36. gets(arr1);

37. gets(arr2);

39. /*定义指针，指向数组的首地址

40. char *p= &arr1[d];

41. char *q= &arr2[0];*/

43. //定义数组arr1和arr2的有效字符长度

44. int l1,l2;

45. l1 = strlen(arr1);

46. l2 = strlen(arr2);

48. if( M < l1 + l2 + 1)

49. {

50. printf("error!!!\n");

51. return -1;

52. }

54. /*while(*p)

55. {

56. p++;

57. }*/

59. /*遍历arr2

60. while(*q)

61. {

63. *p++ = *q++;

64. }*/

65. char *s;

66. s = mystrcat(arr1,arr2,2);

67. printf("连接之后:%s\n",arr1);

69. return 0;

70. }