指针进阶深度剖析

最新推荐文章于 2023-09-09 10:12:38 发布

风吹过你脸颊

最新推荐文章于 2023-09-09 10:12:38 发布

阅读量99

点赞数

文章标签： c语言

本文链接：https://blog.csdn.net/weixin_55079859/article/details/125060508

版权

整理不易，觉得好的麻烦点赞加关注，谢谢支持！后续会继续更新的！

1.字符指针： 存放字符的地址或者字符串的首元素低地址

注意：涉及到字符串常量存放在数组和字符串常量存放首元素地址两种形式

示例1：

#include <stdio.h>
int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    const char *str3 = "hello bit.";
    const char *str4 = "hello bit.";
    if(str1 ==str2)
 printf("str1 and str2 are same\n");
    else
 printf("str1 and str2 are not same\n");
       
    if(str3 ==str4)
 printf("str3 and str4 are same\n");
    else
 printf("str3 and str4 are not same\n");
       
    return 0;
}

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

2.指针数组和数组指针：

示例2：定义

int *p1[10];//指针数组
int (*p2)[10];//数组指针

指针数组：是存放指针的数组，数组p1[10]，存放了10个int*类型的元素。

数组指针：是能够指向数组的指针，p2指针存放的是数组的地址，该数组存放的是10个int类型的元素。

示例3： 形参接收的类型

指针数组：模拟实现二维数组

void test(int* p1[])
{
    int i=0;
    for(;i<3;i++){
      int j=0;
    for(;j<3;j++){
    printf("%d",*(p1[i]+j));
  }
    printf("\n");
  }
}
int main()
{
    int arr1[3]={1,2,3};
    int arr2[3]={3,4,5};
    int arr3[3]={5,6,7};
    int* p1[]={arr1,arr2,arr3};
    test(p1);

    return 0;
}

示例4：

数组指针：在二维数组中的应用

void test(int(*p)[3])
{
    int i=0;
    for(;i<3;i++){
         int j=0;
           for(;j<3;j++){
                printf("%d ",*(*(p+i)+j));
}
   printf("\n");                 
}

}
int main()
{
    int arr[3][3]={{1,2,3},{3,4,5},{5,6,7}};
    test(arr);
    return 0;
}

3.数组名和&数组名的区别：

int main()
{
	int arr[10] = { 0 };
	printf("%p\n",arr);
    printf("%p\n", &arr);
	printf("%p\n", &arr[0]);
	printf("%p\n",arr+1);
	printf("%p\n",&arr+1);
	return 0;
}

总结：根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。而arr是首元素地址，故和&arr[0]相同，（细细体会一下）本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。

4.二维数组的传参：

示例5：

1.以数组的形式传参：

void test (int arr[][5])//也可以吧第一个[]内的数字写上
{


}
int main()
{
   int arr[3][5]={0};
   test(arr);
    return 0;
}

总结：函数形参的接受类型若是以数组的形式，只能省略第一个[ ]内的数字，即一维的数字。因为对一个二维数组，可以不知道有多少行，但是必须知道一行中有多少元素，即多少列。这样才方便计算。

示例6：

2.以数组指针的形式传参：

void test(int(*p)[5])
{


}
int main()
{
     int arr[3][5]={0};
     test(arr);

     return 0;
}

总结：函数形参的接受类型若是以指针的形式，则必须是以数组指针类型接受，因为二维数组数组名，也是首元素的地址，此时首元素地址，也是第一行一维数组的地址，即指向数组的地址。

5.数组指针和二级指针的区别：

示例7：

数组指针：

int main()
{
    int arr[5]={0};
    int (*p)[5]=&arr;//取出数组arr的地址
    
    return 0；
}

示例8：

二级指针：

int main()
{   
    int n=5;
    int* p1=&n;
    int** p2=&p1;//取出一级指针变量的地址
    return 0;
}

总结：数组指针：存的是数组的地址，二级指针：存的是一级指针变量的地址

5.函数指针：

示例8：

#include<stdio.h>
void test()
{
    printf("hehe\n");
}
int main()
{
     printf("%p\n",test);
     printf("%p\n",&test);
     return 0;
}

总结：函数名和&函数名都表示函数的地址，没有区别，这个跟数组名和&数组名有区别。

6.函数指针和函数指针数组：

示例9：

int(*p1)(int int);//函数指针
int(*parr[10])(void);//函数指针数组

总结：

函数指针：函数指针是存放函数的地址。

函数指针数组：数组里面存放的每个元素都是函数指针类型，即存放的是函数的地址

7.指向函数指针数组的指针：

示例10：

void test(const char*str)
{
    printf("%s\n",str);
}
int main()
{
    void (*pf)(const char*)=test;//函数指针pf
    void (*pfarr[5])(const char*);//函数指针数组
    pfarr[0]=test;
    void(*(*ppf)[10])(const char*)=&pfarr;//指向函数指针数组pfarr的指针ppf
    return 0;
}

总结：指向函数指针数组的指针：该指针指向一个数组，数组的每个元素类型都是函数指针类型，即存放的都是函数的地址

8.回调函数：

qsort的实现：

示例11：

#include<stdio.h>
#include<stdlib.h>
int int_cmp(const void *e1,const void *e2)
{

    return *(int*)e1-*(int*)e2;
}
int main()
{
     int arr[]={1,3,5,7,9,2,4,6,8,0};
     int sz=sizeof(arr)/sizeof(arr[0]);
     qsort(arr,sz,sizeof(arr[0]),int_cmp);//qsort函数的使用者得实现一个比较函数
     for(int i=0;i<sz;i++)
    {
         printf("%d ",arr[i]);
    }

    return 0;
}