指针进阶

xkroy

已于 2024-03-27 15:16:47 修改

阅读量785

点赞数 17

分类专栏： C 文章标签： c语言

于 2023-12-12 10:31:58 首次发布

本文链接：https://blog.csdn.net/xkroy/article/details/134711058

版权

C 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

在指针初阶已经接触过了，知道指针的概念：

1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间

2.指针的大小是固定的4/8个字节（32位平台/64位平台）

3.指针是有类型的，指针的类型决定了指针的+-整数的步长，指针解应用操作的时候的权限。

4.指针的运算

下面继续探讨指针的高级主题

一.字符指针

在指针类型中我们知道有一种指针类型为字符指针char*

一般使用：

int main()
{
    char ch='w';
    char*pc=&ch;
    *pc='w';
    return 0;
}

还有一种使用方法如下：

int main()
{
    const char* pstr="hello world."; //这里的意思是把字符串的首字符地址放到指针中
    printf("%s\n",pstr); //打印字符串时，只需要放首地址就行，不用解应用
    return 0;    //因为这里字符串是个常量，无法改变，为了避免错误，在指针前加上const
}

那就有这样的题：

答案是：not same / same

1和2是两个不同的数组，所以地址不同

而3和4指向的是同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际上会指向同一块内存

二.指针数组

在指针初阶中已经学了

三.数组指针

1.数组指针的定义

存放数组地址的指针，指向数组的指针

下面哪个代码是数组指针？

int *p1[10];
int (*p2)[10];

答：p1是指针数组，p2是数组指针

解释：p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组，所以p是一个指针，指向一个数组，叫数组指针

这里要注意：[]的优先级高于*号，所以必须加上（）来保证p先和*结合

初始化：int （*p2）[10]=&arr;

2.&数组名VS数组名

对于下面的数组：

int arr[10];

arr和&arr分别是啥？我们知道arr是数组名，数组名表示数组首元素的地址，那&arr数组名到底是啥？我们来看一段代码：

arr+1跳过的是一个类型（4）的地址，而&arr+1跳过的是整个数组的地址（40）

数组名：数组首元素的地址

&数组名：是数组的地址，只有数组的地址才需要数组指针来接收

数组首元素的地址和数组的地址从值的角度来看是一样的，但是意义不一样

注：除了以下两种情况，所有的数组名都是数组首元素的地址

sizeof（单独一个数组名），数组名表示整个数组，计算的是整个数组的大小，单位是字节
&数组名，数组名表示整个数组，取出的是整个数组的地址

3.数组指针的使用

1.那数组指针怎么使用呢？既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址，看代码：

int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,0};
    int (*p)[10]=&arr;//把数组arr的地址赋值给数组指针变量p
    //但是我们一般很少这样写代码
    return 0;
}

2.实用用法（打印二维数组）

一个二维数组的数组名是第一行一维数组的地址，也就是整个一维数组的地址

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

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

3.学了指针数组和数组指针回顾并看看下面代码的意思：

int arr[5]; //整型数组，数组是5个元素
int *parr1[10]; //指针数组，数组10个元素，每个元素是int*类型的
int (*parr2)[10]; 
//parr2是数组指针，该指针指向一个数组，数组是10个元素，每个元素是int类型的
int (*parr3[10])[5];
//数组指针，该指针指向parr3这个数组，数组有10个元素，
//数组的每个元素的类型是：int（*）[5]的数组指针类型

四.数组参数，指针参数

在写代码时难免要把数组或者指针传给函数，那函数的参数如何设计呢？

1.一维数组传参

2.二维数组传参

二维数组数组名表示的是第一行这个一位数组的地址，不能用int*接受，要用数组指针

3.一级指针传参

思考：当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

4.二级指针传参

思考：当函数参数为二级指针时，可以接收什么参数？

五.函数指针

数组指针是指向数组的指针，函数指针就是指向函数的指针

首先看一段代码：

void test()
{
    printf("hehe\n");
}
int main()
{
    printf("%p\n",test);
    printf("%p\n",&test);
    return 0;
}

输出的结果是:013211DB 013211DB

输出的是两个地址，这两个地址是test函数的地址，那我们的函数的地址想要保存起来，怎么保存？看代码：

void test()
{
    printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void(*pfun1)();
void *pfun2();

首先，能给存储地址，就要求pfun1或者pfun2是指针，pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值为void

再看一段代码：

int add(int x,int y)
{
    return x+y;
}

int main()
{
    int (*pf)(int, int)=&add;
    //==
    int （*pf）(int , int)=add;
    
    int ret=pf(2,3);
    //==
    int ret=(*pf)(2,3);   
    return 0;
}

&函数名和函数名都是函数的地址，使用函数指针时前可以不用解引用*

下面来看两个有趣的代码

( *( void (*) () ) 0 )();

该代码是一次函数调用，调用0地址处的一个函数，首先代码中将0强制转换为void（*）（）函数指针，然后去调用0地址处的函数

void (*signal(int , void(*)(int)))(int);

该代码是一次函数声明，声明的函数名字叫signal，函数的参数有2个，第一个是int类型，第二个是函数指针类型，该函数指针能够指向的那个函数的参数是int，返回类型是void

signal函数的返回类型是一个函数指针，该函数指针能够指向的哪个函数的参数是int，返回类型是void

太复杂，如何简化?

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

函数signal的返回类型和signal的一个参数的类型为void（*）（int），typedef重命名void（*）（int）类型为pfun_t

typedef只有对指针重命名时新的类型需要放到*的旁边

函数指针，返回类型

int (*(*f(int, int))(int);

这个*f一个指针，指向一个函数，函数的参数是int，int，返回类型是int(*)(init);一个函数指针，参数是int，返回类型是int

六.函数指针数组

数组是一个存放相同类型数据的存储空间，我们已经学习了指针数组，那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr[10])(int ,int);

parr先和[]结合，说明parr是数组，数组的内容是int (*)(int， int)类型的函数指针

函数指针的用途：转移表

例子：计算器

int add(int x, int y)
{
    return x+y;
}

int sub(int x, int y)
{
    return x-y;
}

int mul(int x, int y)
{
    return x*y;
}

int div(int x, int y)
{
    return x/y;
}

int (*pf[5])(int, int)={NULL, add,sub, mul, div}

int main()
{
    int input=0;
    int x=0;
    int y=0;
    int ret=0;
    do
    {
        menu();
        printf("请选择:");
        scanf("%d",&input);
        if(input==0)
        {
            printf("退出计算器\n");
            break;
        }
        else if(input>=1 && input<4)
        {
            printf("请输入两个操作数:")
            scanf("%d %d",&x,&y);
            ret=pf[input](x,y);
            printf("%d\n",ret);
        }
    }while(input);
    return 0;
}

函数的地址就是函数名

七.指向函数指针数组的指针

函数指针数组：int (*pf）[5](int , int );

指向函数指针数组的指针：int(*(*ppf)[5](int , int)=&pf; 这是个指针，指向数组，数组元素是int(*）[5](int , int)函数指针

怎么写？先写出一个函数指针int (*pf）[5](int , int ); 然后写出函数指针数组int (*pf）[5](int , int );，最后再写出指向函数指针数组的指针int(*(*ppf)[5](int , int)

这里int(*(*ppf)[5](int , int)的5指的是ppf指向的数组有5个元素

八.回调函数(这是个概念不是一个函数）

回调函数就是通过函数指针调用的函数，如果把函数指针（地址）作为参数传输给另外一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现

方直接调用，而是在特定的时间或条件发生时由另一方调用的，用于该事件或条件进行响应。

实例:

被调用的函数就是回调函数

九.qsort（排序函数）

头文件：stdlib.h

void qsort(void* base,size_t sum, 
size_t width, int(*cmp)(const void* elem1, const void* elem2));
//size_t是无符号整型

base:待排序数组的起始位置

num：数组元素个数

width:一个元素是几个字节(大小)

int(*cmp)：比较函数：e1是比较的第一个元素地址，e2是比较的后面一个元素地址。void* 的好处是任何类型都可以放进来，但不能直接用（垃圾桶）

1.比较函数

返回正数是>升序，负数是<降序

整型：

int cmp_int(const void*e1, const void*e2)
{
    return*（int*)e1- *(int*)e2; //升序
}

int cmp_int(const void*e1, const void*e2)
{
    return*（int*)e2- *(int*)e1; //降序
}

结构体：

struct stu
{
    char name[20];
    int age;
};

int cmp(const void* e1, const void* e2)
{
    return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
    //名字比是字符串比较，用strmp
}

    int main()
    {
        struct stu s[3] = { {"zhangsan",20}, {"list",50} , {"wangwu", 33} };
        int sz = sizeof(s) / sizeof(s[0]);
        qsort(s, sz,  sizeof(s[0]), cmp);
        return 0;
    }

2.用冒泡排序实现qsort

void swap(char* buf1, char* buf2, int width)
{
    int i = 0;
    for (i = 0; i < width; i++)
    {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;
        buf1++;
        buf2++;
    }
}

void bubble_sort(void* base, size_t sz, size_t width, int(*cmp)(const void*, const void*))
//因为不知道排序的是整型/字符数组/结构体，所以用void*base接收一个地址
//要写循环所以要知道元素个数用size_t sz接收
//要确定类型用size_t width接收
//比较函数cmp
{
    //趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        //一趟冒泡排序
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            if (cmp((char*)base + j * width, (char*) base + (j + 1) *  width ) > 0)
                //强制转换成char指针再*宽度就能得出一个元素需要跳过的字节
            {
                //交换
                swap((char*)base + j * width, (char*) base + (j + 1) *  width, width );
            }
        }
    }
}