【搞透C语言指针】那年我双手插兜, 不知道指针是我的对手(二)

简介: 【搞透C语言指针】那年我双手插兜, 不知道指针是我的对手

六. 函数指针数组

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


int (*parr[10])()


解释:parr1就是一个数组,数组的内容就是int (*)()类型的函数指针


1.函数指针的使用

写一个简单的计算器

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;
}
void menu()
{
  printf("******************************\n");
  printf("****   1. add    2.sub   *****\n");
  printf("****   3. mul    4.div   *****\n");
  printf("****   0. exit           *****\n");
  printf("******************************\n");
}
#include<stdio.h>
int main()
{
  int input = 0;
  int x = 0;
  int y = 0;
  int ret = 0;
  do
  {
    menu();
    printf("请选择:>");
    scanf("%d", &input);
    switch (input)
    {
    case 1:
      printf("请输入两个操作数:>");
      scanf("%d %d", &x, &y);
      ret = Add(x, y);
      printf("%d\n", ret);
      break;
    case 2:
      printf("请输入两个操作数:>");
      scanf("%d %d", &x, &y);
      ret = Sub(x, y);
      printf("%d\n", ret);
      break;
    case 3:
      printf("请输入两个操作数:>");
      scanf("%d %d", &x, &y);
      ret = Mul(x, y);
      printf("%d\n", ret);
      break;
    case 4:
      printf("请输入两个操作数:>");
      scanf("%d %d", &x, &y);
      ret = Div(x, y);
      printf("%d\n", ret);
      break;
    case 0:
      printf("退出计算器\n");
      break;
    default:
      printf("选择错误\n");
      break;
    }
  } while (input);
  return 0;
}

以上代码有没有发现有些许冗余了,未来如果有需要添加整型的其他运算,如<< >> & | ^ ……等运算,代码太冗长,那有没有什么办法将代码给简化一下呢?直接上代码:


2.函数指针数组的应用

以下代码改为了转移表的形式,转移表主要用指针数组来实现,每个元素存一个函数指针,我们只要通过已定义好的编号来进行访问。

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;
} 
void menu()
{
  printf("******************************\n");
  printf("****   1. add    2.sub   *****\n");
  printf("****   3. mul    4.div   *****\n");
  printf("****   0. exit           *****\n");
  printf("******************************\n");
}
#include<stdio.h>
int main()
{
  int input = 0;
  int x = 0;
  int y = 0;
  int ret = 0;
  //转移表
  int (*pfarr[5])(int,int) = { NULL,Add,Sub,Mul,Div };
                  //0   1    2   3   4
  do
  {
    menu();
    printf("请选择:>");
    scanf("%d", &input);
    if (input >= 1 && input <= 4)
    {
      printf("请输入两个操作数:>");
      scanf("%d %d", &x, &y);
      ret = pfarr[input](x, y);
      printf("%d \n", ret);
    }
    else if (input == 0)
    {
      printf("退出计算器\n");
    }
    else
    {
      printf("输入有误\n");
    }
  } while (input);
  return 0;
}

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

指向函数指针数组的指针是一个 指针,该指针指向一个 数组 ,数组的元素都是 函数指针

int Add(int x, int y)
{
  return x + y;
}
int Sub(int x, int y)
{
  return x - y;
}
int main()
{
  int (*pf)(int, int) = Add;
  //函数指针数组
  int (* pfArr[4])(int, int) = {Add, Sub};
  //
  int (*(* ppfArr)[4])(int, int) = &pfArr;//ppfArr是一个指向函数指针数组的指针变量
  return 0;
}

以上代码中的int (*(* ppfArr)[4])(int, int)就是一个指向函数指针数组的指针,(* ppfArr)可以看出ppfArr是一个指针变量,加上[4]说明是一个数组指针,指针指向的是一个数组,该数组的元素是什么呢?剩余部分就是数组的元素类型了(函数指针),由此,我们将其一步步拆开看,  其实就是一个指针,指向的是一个数组,数组的每个元素类型是函数指针。


八. 回调函数

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


什么意思呢?


我们将上面函数指针数组部分写的简单计算器,觉得冗余的代码,应用在此场景,作出修改编写如下。

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;
}
void menu()
{
  printf("******************************\n");
  printf("*****1.add   2.sub************\n");
  printf("*****3.mul   4.div************\n");
  printf("********0.exit ***************\n");
  printf("******************************\n");
}
void  Calc(int (*pf)(int,int))
{
  int i = 0, j = 0;
  printf("请输入两个整数:>");
  scanf("%d %d", &i, &j);
  printf("%d\n", pf(i, j));
}
#include<stdio.h>
int main()
{
  int input = 0;
  do
  {
    menu();
    printf("请选择:>");
    scanf("%d", &input);
    switch (input)
    {
    case 1:
      Calc(Add);
    case 2:
      Calc(Sub);
    case 3:
      Calc(Mul);
    case 4:
      Calc(Div);
    case 0:
      printf("退出计算器\n");
      break;
    default:
      printf("输入有误\n");
      break;
    }
  } while (input);
  return 0;
}

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


九、qsort函数的应用

qsort 为quick sort的简写,意为快速排序,主要用于对各种类型的数组进行排序,需要引用头文件中


下面我们来看看它的用法


首先我们在 https://legacy.cplusplus.com/ 网站的旧版本,找到对qosrt函数具体规则的描述。


在搜索框搜索qsort,显示如下:


image.png

观察以上图的绿色字体部分,就是官方对于qsort函数的声明


void qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))

解释:


base -- 指向要排序的数组的第一个元素的指针。

num -- 由 base 指向的数组中元素的个数。

size -- 数组中每个元素的大小,以字节为单位。

compar -- 用来比较两个元素的函数

qsort可以排序任意类型的数据


如果读者知道冒泡排序的算法,是如何实践的,我们可能就知道在比较两个整型的时候,可以用大于小于操作符来比较,在比较字符串的时候,我们可以使用strcmp函数,但是对于两个结构体数据,指定的比较的标准是什么呢?


所以我们不妨设计统一的标准,使各种类型数组元素都可以进行排序,具有通用性。


qsort在声明函数时的参数int (*compar)(const void*, const void*)就是让使用者,指定一个比较的方法(使用者写一个函数,对应此时的函数指针的标准),那么compar函数指针的具体规则是什么呢?


函数指针指向的函数,比较的是两个元素的大小,而p1和p2是待排序的两个元素的地址。


如果p1指向的元素小于p2指向的元素,则返回值是一个小于0的数值;


如果p1指向的元素等于p2指向的元素,则返回值是一个等于0的数值;


如果p1指向的元素大于p2指向的元素,则返回值是一个大于0的数值。


(0默认排序为升序,若想要排序为降序,将p1与p2调换即可)

image.png

话不多说,下面直接上代码。

1.利用qsort来排序整型数组


         
void print_arr(int arr[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
}
//void表示无具体类型的指针,他可以接收任何类型的地址
int compar(const void* p1, const void* p2)
{
  //使用者在使用的时候需要访问几个字节,
  //就需要进行强制类型转换,为指向的元素类型是什么类型的指针
  //如元素地址是int*类型,就需要强制转换为int*
  return *(int*)p1 - *(int*)p2;   //若将p1和p2调换,则打印的是降序顺序
}
#include<stdlib.h>
#include<stdio.h>
int main()
{
  int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
  int sz = sizeof(arr) / sizeof(arr[0]);
    //qsort默认排成升序
  qsort(arr, sz, sizeof(arr[0]), compar);
  print_arr(arr,sz);
  return 0;
}

将结果打印:

image.png

2 利用qsort来排序结构体数据

首先编写一个简单的结构体

 struct Stu
{
  char name[20];
  int age;
};
int main()
{
  struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangwu",30}};
  return 0;
}

 按照年龄的大小来排序(升序)

struct Stu
{
  char name[20];
  int age;
};
//按照年龄来排序
int cmp_stu_by_age(const void* p1,const void* p2)
{
  return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
#include<stdio.h>
#include<stdlib.h>
int main()
{
  struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangwu",30}};
  int sz = sizeof(s) / sizeof(s[0]);
  qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
  return 0;
}

按F10调试代码,

image.png

排序后的结果正是我们想要的结果

image.png

数组从小到大排列,age分别是18,20,30


按照名字的大小来排序(升序)


字符串比较大小需要用到strcmp函数,在比较字符串时, 按照一位一位进行比较,本质比较的是其字符的ACSII码值,若字符串的第一位字符串的ASCII码值与另一个字符串的第一位字符的ASCII码值相等,继续向后比较两者的第二位ASCII码值、第三位……以此类推。


strcmp()函数的比较规则如下:                                                         需要引用头文件


如果字符串1的第n位的ASCII码值大于字符串2的第n位的ASCII码值 则输出结果:1,表示字符串1 > 字符串2;

如果字符串1与字符串2每一位的ASCII码值都相等,而且长度相同, 则输出结果:0 表示字符串1 == 字符串2;

字符串1的第n位的ASCII码值小于字符串2的第n位的ASCII码值,则输出结果:-1 表示字符串1 < 字符串2;

struct Stu
{
  char name[20];
  int age;
};
//按照名字来排序
int cmp_stu_by_name(const void* p1, const void* p2)
{
  return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
  struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangwu",30}};
  int sz = sizeof(s) / sizeof(s[0]);
  qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
  return 0;
}

调试代码

image.png

排序后的结果正是我们想要的结果

image.png

字符串相比较,两两元素从第一个字符的ASCII码值进行比较,按照元素的大小,'l'<'w'<'z',第一个字符比较出了结果,就不需要进行比较第二个字符ASCII码值的大小了。


十、以冒泡排序的思想,模拟实现qsort函数

我们知道了qsort函数的用法,下面我们就使用冒泡排序的思想实现一个类似于qsort函数的适用于各种类型的冒泡排序。


先在main函数里,将排序的数组,和打印内容罗列下来。  

#include<stdio.h>
int main()
{
  int arr[] = { 3,1,5,2,4,9,8,6,5,7 };
  int sz = sizeof(arr) / sizeof(*arr); //sizeof(*arr)表示首元素
  int i = 0;
  printf("排序前:>");
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
      bubble_sort(arr, sz, sizeof(*arr), cmp_int);//实现通用的冒泡排序
  printf("排序后:>");
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

下面编写bubble_sort函数的内部逻辑:

//以冒泡排序思想模拟实现
//bubble_sort可以排序任意类型数组的数据
void bubble_sort(void* base,int num,int width,int (*cmp)(const void* p1, const void* p2))
{
  int i = 0;
  //趟数
  for (i = 0; i < num - 1; i++)
  {
    int flag = 1;//假设该趟数有序
    //每趟冒泡排序的过程
    int j = 0;
    for (j = 0; j < num - 1 - i; j++)
    {
      //两两元素进行比较
      //将base强转为char* + j乘以每个元素的大小, 相当于跳过了j*width个字节
      //将base强转为char* + (j + 1)乘以每个元素的大小, 相当于跳过了(j+1)*width 个字节
      if (cmp_int((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
      {
        flag = 0;//有交换就置为0
        //交换
        //封装一个Swap函数,用来交换元素
        Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
      }
    }
    if (flag == 1)
      break;
  }
}

将两个元素的交换部分,封装一个Swap()函数,专门在这个函数里面编写。

//传过来的是char*类型,如果要修改元素的大小,则需要将元素的每个字节进行交换
//所以这里也就是为什么要将width传递过来的原因了。
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++;
  }
}

最后,使用者自己编写一个比较元素的大小的函数。

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

最后将整体代码放在下面。

int cmp_int(const void* p1,const void* p2)
{
  return *(int*)p1 - *(int*)p2;
}
//传过来的是char*类型,如果要修改元素的大小,则需要将元素的每个字节进行交换
//所以这里也就是为什么要将width传递过来的原因了。
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++;
  }
}
//以冒泡排序思想模拟实现
//bubble_sort可以排序任意类型数组的数据
void bubble_sort(void* base,int num,int width,int (*cmp)(const void* p1, const void* p2))
{
  int i = 0;
  //趟数
  for (i = 0; i < num - 1; i++)
  {
    int flag = 1;//假设该趟数有序
    //每趟冒泡排序的过程
    int j = 0;
    for (j = 0; j < num - 1 - i; j++)
    {
      //两两元素进行比较
      //将base强转为char* + j乘以每个元素的大小, 相当于跳过了j*width个字节
      //将base强转为char* + (j + 1)乘以每个元素的大小, 相当于跳过了(j+1)*width 个字节
      if (cmp_int((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
      {
        flag = 0;//有交换就置为0
        //交换
        //封装一个Swap函数,用来交换元素
        Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
      }
    }
    if (flag == 1)
      break;
  }
}
#include<stdio.h>
int main()
{
  int arr[] = { 3,1,5,2,4,9,8,6,5,7 };
  int sz = sizeof(arr) / sizeof(*arr); //sizeof(*arr)表示首元素
  int i = 0;
  printf("排序前:>");
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
      bubble_sort(arr, sz, sizeof(*arr), cmp_int);//实现通用的冒泡排序
  printf("排序后:>");
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

image.png

目录
相关文章
|
2月前
|
存储 编译器 C语言
【C语言】指针大小知多少 ?一场探寻C语言深处的冒险 !
在C语言中,指针的大小(即指针变量占用的内存大小)是由计算机的体系结构(例如32位还是64位)和编译器决定的。
186 9
|
2月前
|
安全 程序员 C语言
【C语言】指针的爱恨纠葛:常量指针vs指向常量的指针
在C语言中,“常量指针”和“指向常量的指针”是两个重要的指针概念。它们在控制指针的行为和数据的可修改性方面发挥着关键作用。理解这两个概念有助于编写更安全、有效的代码。本文将深入探讨这两个概念,包括定义、语法、实际应用、复杂示例、最佳实践以及常见问题。
65 7
|
2月前
|
存储 NoSQL 编译器
【C语言】指针的神秘探险:从入门到精通的奇幻之旅 !
指针是一个变量,它存储另一个变量的内存地址。换句话说,指针“指向”存储在内存中的某个数据。
124 3
【C语言】指针的神秘探险:从入门到精通的奇幻之旅 !
|
3月前
|
存储 程序员 编译器
C 语言数组与指针的深度剖析与应用
在C语言中,数组与指针是核心概念,二者既独立又紧密相连。数组是在连续内存中存储相同类型数据的结构,而指针则存储内存地址,二者结合可在数据处理、函数传参等方面发挥巨大作用。掌握它们的特性和关系,对于优化程序性能、灵活处理数据结构至关重要。
|
3月前
|
程序员 C语言
C语言中的指针既强大又具挑战性,它像一把钥匙,开启程序世界的隐秘之门
C语言中的指针既强大又具挑战性,它像一把钥匙,开启程序世界的隐秘之门。本文深入探讨了指针的基本概念、声明方式、动态内存分配、函数参数传递、指针运算及与数组和函数的关系,强调了正确使用指针的重要性,并鼓励读者通过实践掌握这一关键技能。
72 1
|
3月前
|
算法 C语言
C语言中的文件操作技巧,涵盖文件的打开与关闭、读取与写入、文件指针移动及注意事项
本文深入讲解了C语言中的文件操作技巧,涵盖文件的打开与关闭、读取与写入、文件指针移动及注意事项,通过实例演示了文件操作的基本流程,帮助读者掌握这一重要技能,提升程序开发能力。
228 3
|
3月前
|
存储 算法 程序员
C 语言指针详解 —— 内存操控的魔法棒
《C 语言指针详解》深入浅出地讲解了指针的概念、使用方法及其在内存操作中的重要作用,被誉为程序员手中的“内存操控魔法棒”。本书适合C语言初学者及希望深化理解指针机制的开发者阅读。
|
3月前
|
存储 C语言 计算机视觉
在C语言中指针数组和数组指针在动态内存分配中的应用
在C语言中,指针数组和数组指针均可用于动态内存分配。指针数组是数组的每个元素都是指针,可用于指向多个动态分配的内存块;数组指针则指向一个数组,可动态分配和管理大型数据结构。两者结合使用,灵活高效地管理内存。
|
3月前
|
存储 NoSQL 编译器
C 语言中指针数组与数组指针的辨析与应用
在C语言中,指针数组和数组指针是两个容易混淆但用途不同的概念。指针数组是一个数组,其元素是指针类型;而数组指针是指向数组的指针。两者在声明、使用及内存布局上各有特点,正确理解它们有助于更高效地编程。
|
3月前
|
存储 C语言
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中,通过定义结构体并使用指向该结构体的指针,可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存,然后通过指针访问和修改结构体成员,最后用 `free` 释放内存,实现资源的有效管理。
276 13

热门文章

最新文章