关于程序员:掌握C语言指针轻松解锁代码高效性与灵活性下

✨✨ 欢送大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C 语言学习
贝蒂的主页：Betty‘s blog

引言

通过后面的刻苦学习，明天咱们终于来到了指针的最初一节，这一节将是对后面内容的总结与深入，置信学完之后，大家能对指针有一个更深的了解~

1. 函数指针

1.1 函数的地址

函数也有地址吗？置信大家看到这里肯定会有这个疑难吧，咱们其实能够做一个小的试验来证实一下。

代码如下：

#include<stdio.h>
int Add(int a, int b)
{return a + b;}
int main()
{
    int x = 1;
    int y = 2;
    int ret = Add(x, y);
    printf("%p \n", Add);// 打印函数名
    printf("%p \n", &Add);// 对函数名取地址
    return 0;
}

从上述试验咱们能够发现，函数确实有地址，并且贝蒂还能够通知大家 函数名 和对函数名取地址 示意的 含意雷同，都是指函数的地址

1.2 函数指针变量

既然函数是有地址的，那咱们就能够用指针来接管，而这个指针咱们称为 函数指针变量

定义如下：

函数的返回值类型（* 指针名）（函数的参数类型）

咱们以下面的加法函数给大家演示一下

int(*pf)(int a, int b) = &Add;
int(*pf)(int , int) = Add;// 省略 &，a 和 b 也是可行的
int(*)(int a, int b)//pf 的函数指针变量类型

1.3 函数指针的应用

    int (*pf)(int a, int b) = &Add;
    int ret1 = (*pf)(3, 5);// 相当于 Add(3,5)
    int ret2 = pf(3, 5);// 相当于 Add(3,5)

1. 对 pf 解援用相当于通过 pf 找到 Add 函数名，而后输出参数进行应用。
2. 而咱们晓得 &Add==Add，所以咱们也能通过间接应用函数指针变量来调用函数。

• 然而函数指针变量不能像其余指针变量进行 +- 运算

2. 两段乏味的代码

2.1 typedef 的应用

typedef 是一个关键字，它能将简单的类型简化。

如：

// 如果你感觉 unsigned long long 写起来麻烦
typedef unsigned long long ull;// 能够将其简化为 ull
unsigned long long a;
ull b;// 也能够这样申明

2.2 代码解析

（1）(*(void (*)())0)();// 这段代码该如何解释

1. 首先咱们从里往外拆分，最外面 void(*)()是一个函数指针类型，它的返回类型是空，参数也为空，咱们能够将其简化为 pf。

那这段代码咱们能够写成这样

    (*(void (*)())0)();
    typedef void(*pf)();
    (*(pf)0)();// 简化后

2. 这下咱们比拟容易看出这段代码是先 将 0 强制类型转换为函数指针类型，而后对其解援用。
3. 解援用之后相当于调用在 0 地址的函数，因为其参数为空所以只有一个独自的().

(2) void (*signal(int , void(*)(int)))(int);// 那这段代码呢

1. 首先 signal 与 () 联合阐明其是一个 函数名，它有两个参数，一个整型，另一个是函数指针类型。
2. 咱们将 signal(int ,void(*)(int))独自拿进去，这段代码只剩 void(*)(int)，这就阐明该函数的返回类型是一个函数指针，指向一个参数为 int，返回为 void 的函数。
3. 咱们能够通过 typedef 进行化简。

    typedef void(*pfun_t)(int);// 将 void(*)(int)简化
    pfun_t signal(int, pfun_t);// 化简之后

3. 计算器

这是一个简略计算机的模仿实现

#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("1:add 2:sub \n");
        printf("3:mul 4:div \n");
        printf("0:exit \n");
        printf("请抉择：");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            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");
            break;
        default:
            printf("抉择谬误 \n");
            break;
        }
    } while (input);
    return 0;
}

通过观察咱们发现代码有很多冗余的局部，咱们能够通过上面两种办法简化

3.1 函数指针数组

类比指针数组，函数指针数组就是每个数组元素是个 函数指针

#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}; 
    // 0 元素不便输出
    // p 先与 [5] 联合是个数组，每个元素是个函数指针
    do
    {printf("1:add 2:sub \n");
        printf("3:mul 4:div \n");
        printf("0:exit \n");
        printf("请抉择：");
        scanf("%d", &input);
        if ((input <= 4 && input >= 1))
        {printf("输出操作数：");
            scanf("%d %d", &x, &y);
            ret = (*p[input])(x, y);
            printf("ret = %d\n", ret);
        }
        else if (input == 0)
        {printf("退出计算器 \n");
        }
        else
        {printf("输⼊有误 \n");
        }
    } while (input);
        return 0;
}

3.2 回调函数

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

简略来说就是通过函数来调用函数

#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;}
void calc(int(*pf)(int, int))
// 用函数指针来接管函数地址
{
    int ret = 0;
    int x, y;
    printf("输出操作数：");
    scanf("%d %d", &x, &y);
    ret = pf(x, y);
    printf("ret = %d\n", ret);
}
int main()
{
    int input = 1;
    do
    {printf("1:add 2:sub \n");
        printf("3:mul 4:div \n");
        printf("0:exit \n");
        printf("请抉择：");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            calc(add);// 传入函数的地址
            break;
        case 2:
            calc(sub);// 传入函数的地址
            break;
        case 3:
            calc(mul)// 传入函数的地址
            break;
        case 4:
            calc(div)// 传入函数的地址
            break;
        case 0:
            printf("退出程序 \n");
            break;
        default:
            printf("抉择谬误 \n");
            break;
        }
    } while (input);
        return 0;
}

4. qsort()函数

4.1 qsort()的应用

1. 申明：void qsort(void base, size_t nitems, size_t size, int (compar)(const void , const void))

• base — 指向要排序的数组的第一个元素的指针。
• nitems — 由 base 指向的数组中元素的个数。
• size — 数组中每个元素的大小，以字节为单位。
• compar — 用来比拟两个元素的函数。

2. 作用：对数组元素进行排序（升序）
3. 返回值：void

举例：

int int_cmp1(const void* p1, const void* p2)
{
    //void* 指针不能间接应用
    return (*(int*)p1 - *(int*)p2);// 前大于后，则替换
}
void test1()
{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_cmp1);
    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {printf("%d", arr[i]);
    }
    printf("\n");
}
int int_cmp2(const void* p1, const void* p2)
{return (*(char*)p1 - *(char*)p2);// 前大于后，则替换
}
void test2()
{char arr[] = {'b','a','j','c','r'};
    int i = 0;
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(char), int_cmp2);
    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {printf("%c", arr[i]);
    }
    printf("\n");
}
int main()
{test1();// 排序整数
    test2();// 排序字符
    return 0;
}

输入后果:

• 当然咱们还能够以字符串，构造体变量为比拟根据，这里贝蒂就不一一列举啦

4.2 冒泡排序

冒泡排序是一种十分常见，用于排序的一种算法。

(1) 算法步骤

1. 比拟相邻的元素。如果第一个比第二个大，就替换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最初一对。这步做完后，最初的元素会是最大的数。
3. 针对所有的元素反复以上的步骤，除了最初一个。
4. 继续每次对越来越少的元素反复下面的步骤，直到没有任何一对数字须要比拟。

(2) 动图演示

（3）代码实现

void bubble_sort(int arr[], int sz) // 参数接管数组元素个数
{
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int flag = 1; // 假如这⼀趟曾经有序了
        int j = 0;
        for (j = 0; j < sz - i - 1; j++)
        {if (arr[j] > arr[j + 1])
            {
                flag = 0; // 发⽣替换就阐明，⽆序
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        if (flag == 1) // 这⼀趟没替换就阐明曾经有序，后续无需排序了
            break;
    }
}
int main()
{int arr[] = {3,1,7,5,8,9,0,2,4,6};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz);
    for (int i = 0; i < sz; i++)
    {printf("%d", arr[i]);
    }
    return 0;
}

输入：

0 1 2 3 4 5 6 7 8 9

4.3 模仿实现 qsort()

尽管 qsort 实质是以疾速排序形式实现的，然而咱们也能够用冒泡排序模拟实现一下。

1. 参数局部必定不会变

void bubble(void *base, int count , int size, int(*cmp)(void *, void *))

2. 比拟函数，因为不同变量类型，所以咱们以 char* 类型来进行比拟。

3. 与比拟函数同理，替换每个字节内容，从而实现两个元素的替换

void _swap(void* p1, void* p2, int size)
//p1 为第一个元素
//p2 为第二元素
//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;
    }
}

残缺代码

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)
            // 返回值大于 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};
    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;
}

结言

​ 🎈🎈 完结撒花，完结撒花🎈🎈

​ 祝贺你，战胜指针大魔王哦~