• c语言指针（深入了解指针）

    前沿：

          有人曾说过不会指针等于没有学习c语言，而我也是非常认同这个观点的，要想学习好c语言，指针是比不可缺少的，如果指针学不会c语言也就没办法学好，而向如此越重要的东西越比较难学，但难学并不代表学不会，这片文章将由简单到复杂让你深刻的了解指针，从此不再害怕指针的学习。

    思维导图：

    目录

    一、指针的初步认识：

    1.1指针是什么：

    1.2指针的类型：

    1.3指针的大小：

    1.4指针的定义和使用：

     1.5野指针：

    二、指针的进阶认识：

    2.1字符指针：

    2.2指针数组：

    2.3数组指针：

    2.4函数指针：

    2.5函数指针数组：

     总结：

    一、指针的初步认识：

    1.1指针是什么：

      1.1.1  学习一个知识我们需要了解他的本质，正如我们学习指针，我们要先了解他是什么，从生活中举例，指针就好比我们家的门牌号一样，每个房间都有自己的门牌号，而我们则可以通过门牌号找到我们想要找到的人，别人也可以通过门牌号找到你。为此我们可以初步的了解指针就表示地址，通过指针我们可以找到相应类型的变量。所以我们平常口语中的指针其实就是指针变量，是用来存放内存地址的变量。

    1.1.2 这样我们就好理解一个变量所占的内存叫做字节，而地址指向的就是所占字节的位置也就是地址。

    这里的0xFFFFFFFFF则就表示地址。

    1.2指针的类型：

           1.2.1 像int double float char 类型一样指针也有自己相应的类型，而指针的类型就是指针所指向元素是什么类型，指向int的指针就是整型指针，指向char类型的就是字符型指针等等。

    1. #include
    2. int main()
    3. {
    4.     int a;
    5.     int *ra=&a;
    6.     char b;
    7.     char* rb=&b; //等等
    8.  
    9.     return 0;
    10. }

    1.3指针的大小：

    1.3.1指针的大小都是确定的在32位的编译器下指针变量的大小都是4个字节，在64位编译器下指针的大小都是8个字节 为啥呢？要知道不管什么类型的指针都是指针变量，而指针变量都是用来存放地址的，所以指针变量的大小取决一个地址存放所需要的空间大小为此不同的编译器有不同的大小但一般都是4/8个字节。

    1.4指针的定义和使用：

    1. #include
    2. int main()
    3. {
    4.     int a=10; //在内存中申请空间 我们也知道局部变量是存放在栈中的
    5.     int* p=&a; //定义一个指针,对变量a取地址用的符号是&，这里a占的字节是四个，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
    6.     printf("%d\n",*p); //*p是对指针的解引用，得到地址所指向的数
    7.     printf("%p\n",p);  //这里可以得到p的地址
    8.     return 0;
    9. }

     1.5野指针：

      1.5.1 什么是野指针：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

    1.5.2野指针形成的原因：

    <1>没有初始化

    1. #include
    2. int main()
    3. {
    4.     int *p; //局部变量的指针没有初始化，默认随机值 这就是个野指针
    5.     return 0;
    6. }

    <2>数组的越界

    1. #include
    2. int main()
    3. {
    4.     int arr[5]={1,2,3,4,5}
    5.     int* p=arr;
    6.     for(int i=0;i<6;i++)
    7.         {
    8.             * (p++)=i;
    9.         }
    10.     return 0;
    11. }

    <3>指针指向的空间释放

    1. #include
    2. #include
    3. int main()
    4. {
    5.     int *p=(int*)malloc(40);
    6.         free(p);
    7.     return 0;
    8.  
    9. }

    1.5.3如何避免野指针：

    <1>. 指针初始化

    <2>. 小心指针越界
    <3>.  指针指向空间释放即使置 NULL
    <4>. 避免返回局部变量的地址
    <5>. 指针使用之前检查有效性

    二、指针的进阶认识：

    2.1字符指针：

    1.   #include
    2.     int main()
    3. {
    4.     char  ch='m';
    5.      char *pr=&ch; //存放字符的指针    
    6.     const char *pr1="hello xiaoma" //存放字符串的指针，他是存放字符传的第一个地址并不是全部地址的存放. 
    7.  //为什要加个const 要知道权限不能被扩大，只能被缩小，*pr1指向的是数组常量不能被改变所以用const来进行修饰。
    8.       printf("%c %s\n",*pr,pr1); //打印字符，和字符串
    9.     return 0;
    10. }

    2.2指针数组：

    2.2.1:指针数组，重点在于数组，是用来存放指针的数组。

    1. int* arr[10]; 存放整型指针的数组
    2. double* arr1[10];存放double型指针的数组
    3. char* arr[10] ； 存放字符型指针的数组

    2.2.2指针数组的应用，可以吧几个一维数组合并成一个二维数组一样。

    1. #include
    2. int main()
    3. {
    4.       int arr1[]={1,2,3,4};
    5.       int arr2[]={3,4,5,6};
    6.       int arr3[]={7,8,9,10};
    7.       int* arr[3]={arr1,arr2,arr3};
    8.        for(int i=0;i<3;i++)
    9.         {
    10.              for(int j=0;j<4;j++)
    11.                  {
    12.                     printf("%d ",arr[i][j]);
    13.                   }
    14.                 printf("\n");
    15.         }
    16.  
    17.     return 0;
    18. }

    2.3数组指针：

    2.3.1 数组指针，重点在于指针，他是指向数组的指针。

    1. int arr[10]={0};
    2. int *p=arr //这里表示p指向arr首元素的地址。这里是整型指针
    3. int (*p1)[10]=&arr;  //这里表示p1指向整个数组的地址 这是数组指针
    4.

    2.3.2 数组指针的应用:数组指针不怎么用在一维指针上大多是用在二维或者三维指针上

    1. #include
    2. void print(int (*p)[3],int x,int y)
    3. {
    4.     for(int i=0;i<3;i++)
    5.     {
    6.         for(int j=0;j<3;j++)
    7.         {
    8.             printf("%d ",*(*(p+i)+j));  //先对p解引用表示指向第一行的地址 加i就是指向第i行的地址 加j表示指向第j列的地址 最后在解引用就得到数值
    9.         }
    10.         printf("\n");
    11.     }
    12. }
    13. int main()
    14. {
    15.     int arr[3][3]={1,2,3,2,3,4,3,4,5};
    16.     print(arr,3,3);
    17.     return 0;
    18. }

    2.4函数指针：

    2.4.1通过数组指针我们类比函数指针，数组指针是指向数组的指针，那么函数指针呢，就是指向函数的指针。

    1. int Add(int x,int y)
    2. {
    3.     return x+y;
    4. }
    5. int (*p)(int,int)=&Add;  //这就是定义一个函数指针p指向的就是Add函数的地址，没错函数也是有自己的地址的

    2.4.2函数指针的简单应用：

    1.  
    2. #include
    3. int Add(int x,int y)
    4. {
    5.     return x+y;
    6. }
    7. int Sub(int x,int y)
    8. {
    9.     return x-y;   // 这是为了我们更好的理解函数指针的应用，所以写的比较简单。
    10. }
    11. int Mul(int x,int y)
    12. {
    13.     return x*y;
    14. }
    15. int Div(int x,int y)
    16. {
    17.     return x/y;
    18. }
    19. void Func(int (*p)(int ,int ),int x,int y)//传的是函数指针
    20. {
    21.     
    22.     int ret = p(x,y);
    23.     printf("%d\n",ret);
    24. }                     //可能觉得没什么用 看一下复杂的应用就知道指针函数的应用
    25.  
    26. int main()
    27. {
    28.     Func(Add,2,3);
    29.     Func(Sub,2,3);
    30.     Func(Mul,3,3);  //这里就是一个函数来实现了加减乘除 而要一个函数实现四个函数的功能则需要运用函数指针
    31.     Func(Div,6,2);
    32.     return 0;
    33. }

    2.4.3函数指针的复杂应用：

       ～～回调函数：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数 的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进 行响应。

             我们上面实现的简单应用就是一个回调函数，而现在我们要实现一个比较复杂的回调函数：

    qsort函数,我们先去了解一下qsort函数怎么使用，这里我比较推荐一个网站就是专门用来查看c/c++库函数：https://legacy.cplusplus.com/https://legacy.cplusplus.com/这里我们来简单的讲述qsort函数：qsort的函数是通过快排的方法来实现不同类型的排序问题，我们来通过代码展示他的使用并且自己来实现一个qsort函数

    1. #include
    2. #include
    3. #include
    4. int swap(const void*p1,const void*p2)
    5. {
    6.     return *(int*)p1-*(int*)p2;
    7. }
    8. int main()
    9. {
    10.     int arr[10]={1,3,6,2,5,4,8,7,10,9};
    11.     int sz=sizeof(arr)/sizeof(arr[0]); //求数组的长度
    12.     qsort(arr,sz,sizeof(int),swap); //第一个要传排序对象的地址，然后排序的长度，宽度，最后排序的判断方法。
    13.     for(int i=0;i
    14.     {
    15.         printf("%d ",arr[i]);
    16.     }
    17.     return 0;
    18. }

    在用qsort按名字排一个结构体：

    1. #include
    2. #include
    3. #include
    4. struct Student
    5. {
    6.     char name[20];
    7.     int age ;
    8. };
    9. int swap(const void*p1,const void*p2)
    10. {
    11.     return strcmp(((struct Student*)p1)->name,((struct Student*)p2)->name);
    12. }
    13.  
    14. int main()
    15. {
    16.     
    17.     struct Student arr[]={{"xiaomma",18},{"lisi",17},{"wanger",20}};
    18.     int  sz=sizeof(arr)/sizeof(arr[0]);
    19.     qsort(arr,sz,sizeof(struct Student),swap);
    20.     for(int i=0;i
    21.     {
    22.         printf("%s\n",arr[i].name);
    23.     }
    24.     
    25.     return 0;
    26. }

    创建自己的qsort函数m_qsort :

    这里m_qsort我用的是冒泡法，虽然效率低了，但是我们要掌握的是函数指针的用法！

    1. void Swap(char*buf1,char*buf2,int width){
    2.     int i=0;
    3.     for(i=0;i//进行位置的交换
    4.     {
    5.         char tmp=*buf1;
    6.         *buf1=*buf2;
    7.         *buf2=tmp;
    8.         buf1++;
    9.         buf2++;
    10.     }
    11. }
    12.   //这里是实现和qsort一样的功能不过我使用的冒泡的形式来实现的
    13.    void bubble_sort(void* base ,int sz,int width,int (*cmp)(const void*e1,const void*e2))
    14. {
    15.     int i=0;
    16.     int j=0;
    17.     for(i=0;i-1;i++)
    18.     {
    19.         for(j=0;j-1;j++)
    20.         {
    21.             if(cmp((char*)base+j*width,(char*)base+(j+1)*width)>0)
    22.             {
    23.                 Swap ((char*)base+j*width,(char*)base+(j+1)*width,width);
    24.                 //因为比较类型不同所以用char传地址比较好，char才占一个地址，我们知道总长度也知道宽度就好进行交哈。
    25.             }
    26.         }
    27.     }
    28. }
    29.  
    30. int cmp_int(const void* e1,const void*e2)
    31. {
    32.     return (*(int *)e1-*(int *)e2);
    33. }
    34. int main()
    35. {
    36.     int arr[]={9,8,7,6,5,4,3,2,1,0};
    37.     int sz=sizeof(arr)/sizeof(arr[0]);
    38.     bubble_sort(arr,sz,sizeof(arr[0]),cmp_int);
    39.     for(int i=0;i
    40.     {
    41.         printf("%d ",arr[i]);
    42.     }
    43.     return 0;
    44. }

      代码很长但很有必要自己来实现一下就能够深入的理解函数指针存在的意义啦，如果要有不理解的地方可以直接问我的。^ _ ^

    2.5函数指针数组：

           2.5.1函数指针数组也就是存放函数指针的数组。

        

    1.  int Add(int x,int y)
    2. {
    3.     return x+y;
    4. }
    5.  int (*p)(int ,int )=&Add //函数指针 
    6.  int (*arr[4])(int,int ); //函数指针数组  //通过对比我们就很容易发现就是把p换成一个数组 他的类型就是函数指针数组 
    7.  int (*(*prr)[5])(int ,int )//函数指针数组的指针。哈哈哈哈类似于套娃是的 就是便于大家取了解这个东西
    8.

      2.5.2函数指针数组的应用：也是很容易的可以把我们上面写的四个功能用一遍

    1. #include
    2. int Add(int x,int y)
    3. {
    4.     return x+y;
    5. }
    6. int Sub(int x,int y)
    7. {
    8.     return x-y; 
    9. }  
    10. int Mul(int x,int y)
    11. {
    12.     return x*y;
    13. }
    14. int Div(int x,int y)
    15. {
    16.     return x/y;
    17. }
    18.  
    19.  
    20. int main()
    21. {
    22.     int i=0;
    23. int (*arr[])(int ,int )={Add,Sub,Mul,Div};
    24.           for(i=0;i<4;i++)
    25.         {
    26.             printf("%d\n",arr[i](6,2));
    27.         }
    28.     return 0;
    29. }

     总结：

    1、从指针的初级指针是什么，和如何使用到指针的进阶一大堆不同的指针，这里小马都已经全部写完，还有一个结构体指针，我觉得看过我的链表就应该很容易的掌握，这里我都不进行写啦，我觉得比较难的点就在于函数指针这里的qsort函数自己的实现，我认为很有必要多看几遍自己在写一遍，才能深入理解qsort函数，和函数指针。

    2、最后码文不易，如果觉得文章有帮助的话，请多多关注，希望我们能够一同进步，共同发展！！！！^ _ ^

  • 相关阅读:
    Python中的区块链技术与应用
    IntelliJ IDEA 设置数据库连接全局共享
    深度解析shell脚本的命令的原理之cd
    让div居中的方式的几种方法
    Flutter学习8 - 网络编程 Http
    ubuntu启动程序报错
    PPT如何设置和取消打开密码？
    ARM64-内嵌汇编
    Python少儿编程小课堂（一）入门篇
    Java8新特性 Stream流（可快速上手）
  • 原文地址：https://blog.csdn.net/m0_63177573/article/details/127815649