• Linux C基础（9）

    1、指针的算术元素

    总结：

    1.  p + n:p+n对于p向地址增大的方向移动n个数据
    2.      实际的变化：p + sizeof(数据类型)*n
    3.  p - n:p-n对于p向地址减小的方向移动n个数据
    4.      实际的变化：p - sizeof(数据类型)*n
    5.  p++:p向地址增大的方向移动1个数据
    6.      实际的变化：p + sizeof(数据类型)
    7.  p--:p向地址减小的方向移动1个数据
    8.      实际的变化：p - sizeof(数据类型)
    9.  p - q(p和q的数据类型相同):这两个指针之间相差的数据的个数
    10.      实际变化:(p - q)/sizeof(数据类型)

    注意：

    1.  (1)指针的算术运算只有在操作连续的内存空间的时候才有意义
    2.  (2)p是指针变量，以上这些方法也适用于指针常量，但是++、--除外

    1.2 为什么使用数组名[下标]就可以访问数组中的元素

    总结：

    1.  (1)数组名代表的是数组首元素的地址，地址常量，不能对它进行++、-- ,a的数据类型:int *
    2.  (2)数组名代表的是整个数组 sizeof(a)

    1.3 通过指针常量来访问

    1.  #include 
    2.  void main()
    3.  {
    4.      int a[]={1,2,5,3,8,9,6};
    5.      int *p = a;
    6.      printf("p的起始地址：%d\n",p);//1703716
    7.      printf("*p++ = %d\n",*p++);//1
    8.      /*
    9.  *和++的优先级相同，运算顺序从右向左，所以*p++就相当于*(p++)；
    10.  这里存在一个知识误区：本应该先执行括号内的p++，使p从指向a[0]变成指向a[1]；
    11.  但其实事实并非如此；事实是，对于直接对*p++的输出来说，第一步是运算*p，输出后，第二步再运算p++；
    12.  需要注意的是：*和++对于p的运算，都是单独运算，比如第一步：*p就是对p所指向的地址进行取值，第二步：p++对于p所指向的地址+1个数据类型的字节数；
    13.  */
    14.      printf("*p++后的地址：%d\n",p);//1703720
    15.      printf("*p的值是：%d\n",*p);//2
    16.      printf("a[0]=%d\na[1]=%d\n",a[0],a[1]);//1,2
    17.  }

     *p++(先取值，再自加,地址自加,改变指针指向，所有指针常量不能自增)

    1.  p++ : p = p + 1
    2.  ++是有赋值操作的，所以p的值会被改变
    3.  p+1
    4.  访问p的下一个地址，因为没有对p的赋值操作，所以p值不会被改变。

    1.4 通过指针变量来访问

    1.5 数组的访问

    1.6 易错点

    案例1

    printf()是一个右结合，从右往左

    案例2

    形参都是当作指针来执行的

    案例3

    字符串常量不能被修改，但是可以被访问

    1.7 指针的指向没有发生改变

    1.8 指针的指向发生改变

    案例

     编写一子函数，实现字符串的链接
    1.  指针函数：指的是函数的返回值是一个指针，比如我的函数返回的是一个指向整数int的指针，定义格式如下：
    2.  ​
    3.  int *p(int a,int b); //注意这里的*与P之间是没有括号的，所以含义是函数p(int,int)会返回一个（int *）指针

    2、指针与二维数组

    a+j=&a[j] -> *(a+j)=a -> *(&a[i]+j)=a -> *(*(a+i)+j)=a

    总结：

    1. 1、a、&a[0]、&a[0][0]的值是一样的，但是意义不一样
    2. 2、为什么a不是int **类型的
    3. a+1移动了一个数组（12byte），如果是int **的话加1移动4个字节
    4. 3、a指向a[0]，a[0]是一个一维数组，所以说a指向了一个一维数组

    作业

    1. 以下都封装成子函数的形式（指针移动）:
    2. 1、求一个字符串中有多少个空格
    3. 2、求字符串的长度
    4. 3、字符串的拷贝
    5. 4、字符串的比较
    6. 5、求指定字符在字符串中第一次出现的地址
    7. 6、求指定字符在字符串中最后一次出现的地址
    8. 7、
    9. 1----------字符数组的输入
    10. 2----------输出
    11. 3----------排序

    1、求一个字符串中有多少个空格

    1. #include 
    2. #include 
    3. #define N 30
    4.  
    5. int count(char * arr);
    6.  
    7. int main(void)
    8. {
    9.         int num= 0;
    10.         char arr[N] = "h w h w h w";
    11.         num = count(arr);
    12.         printf("%d\n",num);
    13.         return 0;
    14. }
    15.  
    16. int count(char * arr)
    17. {
    18.         int i,num = 0;
    19.         char *p = arr;
    20.         for(i = 0;i<strlen(arr);i++)
    21.         {
    22.                 if((int)*(p)==32)
    23.                 {
    24.                         num++;
    25.                 }
    26.                 p++;
    27.         }
    28.         return num;
    29. }

    2、求字符串的长度

    1. #include 
    2. #include 
    3. #define N 30
    4.  
    5. int str_long(char * arr);
    6.  
    7. int main(void)
    8. {
    9.         int i,j,num= 0;
    10.         char arr[N] = "hwhwhw";
    11.         num = str_long(arr);
    12.         printf("%d\n",num);
    13.         return 0;
    14. }
    15.  
    16. int str_long(char * arr)
    17. {
    18.         int i,j,num = 0;
    19.         char *p = arr;
    20.         while(*p)
    21.         {
    22.                 num++;
    23.                 p++;
    24.         }
    25.         return num;
    26. }

    3、字符串的拷贝

    1. #include 
    2. #include 
    3. #define N 30
    4.  
    5. void str_cp(char * arr, char * str);
    6.  
    7. int main(void)
    8. {
    9.         char arr[N] = "hello";
    10.         char str[N] = "ok";
    11.         str_cp(arr,str);
    12.         puts(arr);
    13.         return 0;
    14. }
    15.  
    16. void str_cp(char * arr, char * str)
    17. {
    18.         int i,j,num = 0;
    19.         char *p = arr;
    20.         char *pp = str;
    21.         while(*pp)
    22.         {   
    23.                 *p=*pp;
    24.                 p++;
    25.                 pp++;
    26.         }   
    27.         *p = '\0';
    28. }

    4、字符串的比较

    1. #include 
    2. #include 
    3. #define N 30
    4.  
    5. int str_compare(char * arr, char * str);
    6.  
    7. int main(void)
    8. {
    9.         int result = 0;
    10.         char arr[N] = "hxllo";
    11.         char str[N] = "hallo";
    12.         result = str_compare(arr, str);
    13.         printf("%d\n",result);
    14.         return 0;
    15. }
    16.  
    17. int str_compare(char * arr, char * str)
    18. {
    19.         int i,result = 0;
    20.         char *p = arr;
    21.         char *pp = str;
    22.         while(*p && *pp)
    23.         {
    24.                 if(*p != *pp)
    25.                 {
    26.                         break;
    27.                 }
    28.                 p++;
    29.                 pp++;
    30.         }
    31.         result = *p - *pp;
    32.         return result;
    33. }

    5、求指定字符在字符串中第一次出现的地址

    1. #include 
    2. #include 
    3. #define N 30
    4.  
    5. char *str_first(char * arr, char str);
    6.  
    7. int main(void)
    8. {
    9.         char arr[N] = "hello";
    10.         char str = 'e';
    11.         char * result = str_first(arr, str);
    12.         printf("%p\n",arr);
    13.         printf("%p\n",result);
    14.  
    15.         return 0;
    16. }
    17.  
    18. char *str_first(char * arr,char str)
    19. {
    20.         char * result = NULL;
    21.         char * p = arr;
    22.         while(*p)
    23.         {
    24.                 if(*p == str)
    25.                 {
    26.                         result = p;
    27.                         break;
    28.                 }
    29.                 p++;
    30.         }
    31.         return result;
    32. }

    6、求指定字符在字符串中最后一次出现的地址

    1. #include 
    2. #include 
    3. #define N 30
    4.  
    5. char *str_last(char * arr, char str);
    6.  
    7. int main(void)
    8. {
    9.         char arr[N] = "helle";
    10.         char str = 'e';
    11.         char * result = str_last(arr, str);
    12.         printf("%p\n",arr);
    13.         printf("%p\n",result);
    14.  
    15.         return 0;
    16. }
    17.  
    18. char *str_last(char * arr,char str)
    19. {
    20.         char * result = NULL;
    21.         char * p = arr;
    22.         while(*p)
    23.         {   
    24.                 if(*p == str)
    25.                 {   
    26.                         result = p;
    27.                 }
    28.                 p++;
    29.         }
    30.         return result;
    31. }

    7、一个控制台

    1. 1----------字符数组的输入
    2. 2----------输出
    3. 3----------排序
    1. #include 
    2. #include 
    3. #include 
    4. #define N 30
    5.  
    6. void menu();
    7. void input(char * a); 
    8. void output(char * a); 
    9. void swap(char * a); 
    10.  
    11. int main(void)
    12. {
    13.         char arr[30] = {'\0'};
    14.         int fun = 0;
    15.         while(1)
    16.         {
    17.                 menu();
    18.                 printf("请选择功能");
    19.                 scanf("%d",&fun);
    20.                 switch(fun)
    21.                 {
    22.                         case 1:
    23.                                 input(arr);
    24.                                 break;
    25.                         case 2:
    26.                                 output(arr);
    27.                                 break;
    28.                         case 3:
    29.                                 swap(arr);
    30.                                 break;
    31.                         case -1: 
    32.                                 exit(0);
    33.                 }
    34.         }
    35.  
    36.         return 0;
    37. }
    38.  
    39. void menu()
    40. {
    41.         printf("功能菜单\n");
    42.         printf("1-数组的输入\n");
    43.         printf("2-数组的输出\n");
    44.         printf("3-排序\n");
    45.         printf("-1-exit\n");
    46. }
    47. //输入
    48. void input(char * a)
    49. {
    50.         getchar();
    51.         gets(a);
    52. }
    53. //输出
    54. void output(char * a)
    55. {
    56.         //puts(a);
    57.         for(int i=0;i<strlen(a);i++)
    58.                 printf("%c\n",*(a+i));
    59. }
    60. //排序
    61. void swap(char * a)
    62. {
    63.         int i,j,tmp = 0;
    64.         int num = 0;
    65.         char * p = a;
    66.         while(*p)
    67.         {
    68.                 p++;
    69.                 num++;
    70.         }
    71.         printf("%d",num);
    72.         for(i=1;i
    73.         {
    74.                 char * pp = a;  
    75.                 for(j=0;j
    76.                 {
    77.                         if(*(pp)>*(pp+1))
    78.                         {
    79.                                 printf("2\n");
    80.                                 tmp=*pp;
    81.                                 *pp=*(pp+1);
    82.                                 *(pp+1)=tmp;
    83.                         }
    84.                         pp++;
    85.                 }
    86.         }
    87. }

    *(++p)：先加加，再取值

  • 相关阅读:
    数学王国找寻另一半：求一个整数的真因子总和，算法优化解决方案超时问题
    洛谷P1796 汤姆斯的天堂梦
    c++day6实现成模板类
    系统优化与微服务架构、分布式架构的合理性思考
    Windows进程间利用管道通信
    SpringCloud——注册中心nacos
    API对接需求如何做需求调研，需要注意什么？
    hadoop学习笔记-centos环境
    代码整洁之道第四章 注释
    常用的几种异步实现方式
  • 原文地址：https://blog.csdn.net/m0_58540923/article/details/134235770