指针的进阶（下）

KrisZhang10

已于 2023-11-23 11:24:44 修改

阅读量143

点赞数 5

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

于 2023-11-15 00:43:52 首次发布

本文链接：https://blog.csdn.net/m0_61630449/article/details/134406536

版权

C语言高阶专栏收录该内容

9 篇文章 0 订阅

订阅专栏

函数指针

阅读两段有趣的代码：

《C陷阱和缺陷》

//代码1
( *(void (*)())0))();
//代码2
void ( *signal(int, void(*)(int)))(int);

代码1：

1.将0强制类型转换为void(*)()类型的函数指针
这就意味着0地址处放着⼀个函数，函数没参数，返回类型是void
调⽤0地址处的这个函数其实就是⼀次函数调⽤

代码2:

代码2是⼀个函数的声明
函数的名字是signal
signal函数的参数第⼀个是int类型，第⼆个是void(*)(int)类型的函数指针
该函数指针指向的函数参数是int，返回类型是void
signal函数的返回类型也是⼀个函数指针
该函数指针指向的函数参数是int，返回类型是void

意思为void(*(int)signal(int,void(*)(int)));但是不能这样写，所以把int放后⾯去

typedef int* ptr_t;

typedef void(*pf_t)(int);

//将void(*）(int)类型重新起个别名叫pf_t

就可以写成

pf_t signal(int,pf_t);

即：

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

函数指针数组

数组是一个存放相同类型数据的存储空间，比如：

int *arr[10];

//数组的每个元素是int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10])();

parr1 先和 []结合，说明 parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针

函数指针数组的用途：转移表

实现计算器

#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{ 
    return a - b;
}
int mul(int a, int b)
{
    return a*b;
}
int div(int a, int b)
{
    return a / b;
}
int main()
{
    int x, y;
    int input = 1;
    int ret = 0;
    do
    {
        printf( "*************************\n" );
        printf( " 1:add 2:sub \n" ); 
        printf( " 3:mul 4:div \n" ); 
        printf( "*************************\n" ); 
        printf( "请选择：" ); 
        scanf( "%d", &input); 
        switch (input) 
        {
        case1:
            printf( "输入操作数：" ); 
            scanf( "%d %d", &x, &y); 
            ret = add(x, y);
            printf( "ret = %d\n", ret);
            break;
        case 2:
            printf( "输入操作数：" ); 
            scanf( "%d %d", &x, &y); 
            ret = sub(x, y);
            printf( "ret = %d\n", ret);
            break;
        case 3:
            printf( "输入操作数：" );
            scanf( "%d %d", &x, &y); 
            ret = mul(x, y);
            printf( "ret = %d\n", ret);
            break; 
        case 4:
            printf( "输入操作数：" ); 
            scanf( "%d %d", &x, &y); 
            ret = div(x, y);
            printf( "ret = %d\n", ret);
            break; 
        case 0:
            printf("退出程序\n"); 
            breark;
        default:
            printf( "选择错误\n" ); 
            break;
     } 
 } while (input);

return 0;

}

使用函数指针数组的实现：

#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{ 
    return a - b;
}
int mul(int a, int b)
{
    return a*b;
}
int div(int a, int b)
{
    return a / b;
}
int main()
{
    int x, y; 
    int input = 1; 
    int ret = 0; 
    int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表 
    while (input) 
    {
        printf( "*************************\n" ); 
        printf( " 1:add 2:sub \n" ); 
        printf( " 3:mul 4:div \n" ); 
        printf( "*************************\n" ); 
        printf( "请选择：" ); 
        scanf( "%d", &input); 
        if ((input <= 4 && input >= 1)) 
        {
            printf( "输入操作数：" );
            scanf( "%d %d", &x, &y);
            ret = (*p[input])(x, y); 
        } 
        else
           {
            printf( "输入有误\n" ); 
           }   
        printf( "ret = %d\n", ret);
     }
 return 0;

}

指向函数指针数组的指针

指向函数指针数组的指针是一个指针

指针指向一个数组，数组的元素都是函数指针 ;

如何定义?

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

回调函数（qsort）

回调函数就是一个通过函数指针调用的函数。

如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

首先演示一下qsort函数的使用：

qsort是⼀个库函数，是⽤来排序的库函数，底层使⽤的是快速排序的⽅法像在作业中写的冒泡排序，写的时候是int，就只能排int类型。

qsort的好处是：1、现成的 2、可以排序任意类型的数据

使⽤qsort来排序整型数组，这⾥就要提供⼀个⽐较函数这个⽐较函数能够⽐较2个数的⼤⼩

参考cpp官⽹的⽤法描述

void* - ⽆具体类型的指针，所以它可以接收任何类型的地址，但是不能进⾏解引⽤操作

需要进⾏强制转换后，再进⾏* qsort默认是排成升序号，如果要排降序：*( int *)p2 - *(int *) p1

#include <stdio.h>

//qosrt函数的使用者得实现一个比较函数 
int int_cmp(const void * p1, const void * p2) 
{ 
    return (*( int *)p1 - *(int *) p2); 
}

int main() 
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 }; 
    int i = 0;
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp); 
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++) 
    { 
        printf( "%d ", arr[i]); 
    } 
    printf("\n"); 
    return 0;
}

使用回调函数，模拟实现qsort（采用冒泡的方式）。

#include <stdio.h>

int int_cmp(const void * p1, const void * p2) 
{ 
    return (*( int *)p1 - *(int *) p2); 
}

void _swap(void *p1, void * p2, int size) 
{
    int i = 0;
    for (i = 0; i< size; i++)
    {
        char tmp = *((char *)p1 + i);
        *(( char *)p1 + i) = *((char *) p2 + i);
        *(( char *)p2 + i) = tmp;
    }
}

void bubble(void *base, int count , int size, int(*cmp )(void *, void *)) 
{
    int i = 0;
    int j = 0;
    for(i = 0;i < count - 1;i++)
    {
        for (j = 0; j<count-i-1; j++)
        {
            if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0) 
            {
              _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);                                               
            }
        }
    }
} 
int main() 
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    //char *arr[] = {"aaaa","dddd","cccc","bbbb"};
    int i = 0;
    bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
    {
        printf( "%d ", arr[i]);
    } 
    printf("\n"); 
    return 0;
}