浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第1张图片

 

目录

回调函数

用冒泡排序模拟实现qsort函数

qsort函数

回忆冒泡排序

给冒泡排序函数增加新成员

比较函数传参的注意事项

 比较函数

完整代码

指针和数组相关习题讲解

指针笔试题


回调函数

官方定义:

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

代码解释:

#include
void test()
{
	printf("HaHaHa");
}

void print(void (*pr)())//创建一个函数指针接受test函数地址
{
	pr();//间接调用test函数打印 因此 test函数便被称为回调函数
}
int main()
{
	print(test);//不直接调用test函数打印 而是将test函数的地址作为参数传给print函数
	return 0;
}

用冒泡排序模拟实现qsort函数

qsort函数

在模拟实现之前 ,我们要先了解一下qsort函数可以实现什么功能,以及相关参数是什么?

qsort函数实现了一个快速排序算法,其可以对任何数据进行升序排序,但需要传入相关参数。

void qsort( 
void *base,   //待排序数据的起始位置
size_t num,   //数组的元素个数
size_t width, //一个元素的字节大小
int (__cdecl *compare )(const void *elem1, const void *elem2 ) 
//比较函数的函数指针 用来调用比较函数
);//elem1和elem2代表待比较的两个数据的地址  

其中比较函数需要自行创建,返回值为:

< 0 elem1 less than elem2
0 elem1 equivalent to elem2
> 0 elem1 greater than elem2

数组按照比较函数定义的递增顺序排序。要按降序对数组排序,请颠倒比较函数中“大于”和“小于”的含义。

了解完qsort函数的相关参数,那么让我们着手用冒泡排序来实现一样的功能吧!

回忆冒泡排序

#include
void bubble_sort(int* arr, int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)//sz-1趟 一趟排一个数字 最后一个数字不用排 因此为sz-1
	{
		for (j = 0; j < sz - 1 - i; j++) //比较的对数
		{
			if (arr[j] > arr[j + 1]) //若大于就交换 排序完为升序
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int arr[] = { 1,3,5,2,4,7,11,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

给冒泡排序函数增加新成员

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第2张图片

我们可以看到,qsort函数定义时,是用 void*类型的指针来接收地址的,其意义是什么?

因为qsort函数的作者不知道我们即将要排序的数据是什么类型的,int?字符串?又或者是结构体?,他无从而知,所以他将用void*这种具有无限包容性的指针类型来接收,也因此,qsort函数可以对任何数据进行排序。所以,我们在更改冒泡函数时,接收地址的指针类型也要为void*类型.

void bubble_sort(void* base, int num, int width, int (*comp)(void* e1, void* e2))

比较函数传参的注意事项

 我们比较函数需要传入待比较数据的地址,但是我们只知道数据的起始地址base,且他还是void*类型的,那么我们如何用这个参数得到待比较数据的地址呢???又如何对其进行交换呢??

我们都知道内存中是以字节为单位存放数据的,而char*类型的指针每+1,可前进一个字节,正好访问到下一个内存单元,这样,不管任何类型的数据,都可精准访问到,而我们接下来要知道的,就是控制访问的宽度,即 我们拿到的数据存放在几个单元格内,比如int类型的是四个字节,即四个单元格,那么我们如何知道呢?

对咯,我们传入的参数中有个width,即数据的字节大小,在交换的时候,我们一个单元格一个单元格的交换

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第3张图片

交换的问题我们解决了,那么如何传参呢?

其实和交换的道理类似,将首地址转换为char*类型后,再加上width就可以得到第二个数据的地址了。

void bubble_sort(void* base, int num, int width, int (*comp)(void* e1, void* e2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < num - 1; i++)
	{
		for (j = 0; j < num - 1 - i; j++)
		{
			if (comp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
				
		}
	}
}
//swap为交换函数,width是告诉其交换几次,有几个字节(我们所说的单元格)交换几次

 比较函数

我们在写比较函数的代码时,注意形参类型也要为void*,因为我们的函数指针中形参的类型为void*要一一对应,在使用时,将其强制类型转为换对应的类型便可,比如比较的是整型,将其转换为int*型,再解引用进行比较。

完整代码

//test1为整型数组的比较
//test2为结构体数据的比较

#include
#include

int compare(void* e1, void* e2)
{
	return (*((int*)e1) - *((int*)e2));
}
struct stu
{
	char name[10];
	int age;
};

int cmp1(void* e1, void* e2)
{
	strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}

void swap(char* e1, char* e2,int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char temp = *e1;
		*e1 = *e2;
		*e2 = temp;
		e1++;
		e2++;
	}
}

void bubble_sort(void* base, int num, int width, int (*comp)(void* e1, void* e2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < num - 1; i++)
	{
		for (j = 0; j < num - 1 - i; j++)
		{
			if (comp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
				
		}
	}
}


void test2()
{
	struct stu arr[3] = { {"ziu",20},{"wang",23},{"ihang",25} };
	bubble_sort(arr, sizeof(arr)/sizeof(arr[0]), sizeof(arr[0]), cmp1);
}

void test1()
{
	int arr[] = { 10,1,6,7,3,4,5,2,9,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), compare);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test2();
	return 0;
}

指针和数组相关习题讲解

好,那么先让我们复习一下知识点

数组名一般情况下代表首元素的地址,但是有两个例外

1.sizeof(数组名) - 这里的数组名代表整个数组

2.&数组名  这里取出的是整个数组的地址 要用数组指针来接收

(编译器平台为32位)

//一维数组
1.int a[] = {1,2,3,4};
2.printf("%d\n",sizeof(a));
3.printf("%d\n",sizeof(a+0));
4.printf("%d\n",sizeof(*a));
5.printf("%d\n",sizeof(a+1));
6.printf("%d\n",sizeof(a[1]));
7.printf("%d\n",sizeof(&a));
8.printf("%d\n",sizeof(*&a));
9.printf("%d\n",sizeof(&a+1));
10.printf("%d\n",sizeof(&a[0]));
11.printf("%d\n",sizeof(&a[0]+1));

1.数组名单独放在了sizeof内部,这里代表整个数组,即求整个数组的字节大小,又因为元素为int类型,有四个元素,即 16

2.

2、3、5、10、11为一个类型,以第二题为例讲解

这里数组名没有单独放在sizeof内部,所以代表首元素地址,+0后依然是首元素地址,即&a[0]

,因为是地址,地址的大小为 4/8

4.这里的数组名依然表示数组首元素地址,解引用后得到第一个元素,类型为int,即 4

6. *(a+i)相当于a[ i ],即拿到的是元素本身   元素类型为int,所以这里为4

7.&a拿到的是整个数组的地址,但是它依然是地址,是地址大小就为4/8

8.我们从后往前看,首先&a拿到整个数组的地址,再解引用得到整个数组,所以结果是16

   还可以理解为 *与&抵消了,剩下了数组名,而数组名单独放在sizeof内部表示整个数组

9.&a表示拿到整个数组的地址,+1表示跳过了整个数组,但还是地址   4/8

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第4张图片

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第5张图片 

 接下来我将对必要的进行讲解

//字符数组
char arr[] = {'a','b','c','d','e','f'};
1.printf("%d\n", sizeof(arr));
2.printf("%d\n", sizeof(arr+0));
3.printf("%d\n", sizeof(*arr));
4.printf("%d\n", sizeof(arr[1]));
5.printf("%d\n", sizeof(&arr));
6.printf("%d\n", sizeof(&arr+1));
7.printf("%d\n", sizeof(&arr[0]+1));

1.arr单独放在sizeof内部表示整个数组,此数组用字符abcdef来初始化,大小为6

2.数组名没有单独放在sizeof内部,表示地址   4/8

3.*arr -> 字符a  char型  大小为1

4. 1  // 其表示字符b 

5.4/8

6.4/8

7.4/8

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第6张图片

strlen是传入一个地址,从该地址向后计算\0之前的字符数目

//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
1.	printf("%d\n", strlen(arr));
2.	printf("%d\n", strlen(arr + 0));
3.	printf("%d\n", strlen(*arr));
4.	printf("%d\n", strlen(arr[1]));
5.	printf("%d\n", strlen(&arr));
6.	printf("%d\n", strlen(&arr + 1));
7.	printf("%d\n", strlen(&arr[0] + 1));

1.因arr数组初始化时没有放入\0,所以在 ' f ' 后,我们不知道什么时候遇到\0,所以是随机值

2. 与1同理 随机值

3.*arr表示字符a,字符a为97,只要传入strlen,他就会认为这是个地址,但是这里的地址是非法的,可以理解为我们无法访问,因此这是个错误代码(运行时将此代码屏蔽掉)

4.与3同理

5.随机值   

&arr得到的是整个数组的地址,从数值方面来说,整个数组地址与首元素地址一样,所以在strlen这里,它就是从首元素的地址向后计算字符个数

6.此时&arr+1跳到了字符f后面的地址,但是我们依然不知道什么时候遇到\0    所以为随机值

7.从第二个元素后开始计算 结果依然为随机值,但是与1相比结果差1,因为跳过了一个元素

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第7张图片

char arr[] = "abcdef"; //这种初始化方式 f后隐藏了 \0

1	printf("%d\n", sizeof(arr));
2	printf("%d\n", sizeof(arr + 0));
3	printf("%d\n", sizeof(*arr));
4	printf("%d\n", sizeof(arr[1]));
5	printf("%d\n", sizeof(&arr));
6	printf("%d\n", sizeof(&arr + 1));
7	printf("%d\n", sizeof(&arr[0] + 1));

1.7   &arr为整个数组,因为隐藏了\0,所以为7

2.4/8

3.1   *arr得到字符a 

4.1    arr[1] -> 字符b

5.4/8 

6.4/8  地址的大小

7.4/8

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第8张图片

	char arr[] = "abcdef";
1	printf("%d\n", strlen(arr));
2	printf("%d\n", strlen(arr + 0));
3	printf("%d\n", strlen(*arr));
4	printf("%d\n", strlen(arr[1]));
5	printf("%d\n", strlen(&arr));
6	printf("%d\n", strlen(&arr + 1));
7	printf("%d\n", strlen(&arr[0] + 1));

1.6          计算的是 \0 之前的字符个数

2.7

3.错误代码   *arr -> 'a' -> 97

4.错误代码

5.6         

&arr是整个数组的地址 但依然从首元素地址处开始计算,从数值方面来说,整个数组地址与首元素地址一样

6.随机值          f后的空间中存的是什么我们无从得知,不知道什么时候遇到\0,所以为随机值

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第9张图片        

7.5          从b处开始计算

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第10张图片

	char* p = "abcdef";
1	printf("%d\n", sizeof(p));
2	printf("%d\n", sizeof(p + 1));
3	printf("%d\n", sizeof(*p));
4	printf("%d\n", sizeof(p[0]));
5	printf("%d\n", sizeof(&p));
6	printf("%d\n", sizeof(&p + 1));
7	printf("%d\n", sizeof(&p[0] + 1));

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第11张图片

1.4/8          p为指针,存放首元素地址

2.4/8          p+1为第二个元素的地址

3. 1            *p->'a'->char型->大小为1

4. 1             p[0] 等价于 *(p+0) 为'a'

5.4/8           &p表示地址

6.4/8

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第12张图片

7.4/8             &p[0]+1 -> &(*(p+0) ) +1  ->表示字符b的地址

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第13张图片

	char* p = "abcdef";
1	printf("%d\n", strlen(p));
2	printf("%d\n", strlen(p + 1));
3	printf("%d\n", strlen(*p));
4	printf("%d\n", strlen(p[0]));
5	printf("%d\n", strlen(&p));
6	printf("%d\n", strlen(&p + 1));
7	printf("%d\n", strlen(&p[0] + 1));

 1.6

2.5     从字符b开始计算

3.错误代码    *p为字符a   (运行时记得屏蔽)

4.错误代码

5.随机值

6.随机值

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第14张图片

7.5     从b处开始计算

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第15张图片 

二维数组薄弱的同学这道题建议大家反复食用!!!!(当然也包括作者本人!!!)

	//二维数组
	int a[3][4] = { 0 };
1	printf("%d\n", sizeof(a));
2	printf("%d\n", sizeof(a[0][0]));
3	printf("%d\n", sizeof(a[0]));
4	printf("%d\n", sizeof(a[0] + 1));
5	printf("%d\n", sizeof(*(a[0] + 1)));
6	printf("%d\n", sizeof(a + 1));
7	printf("%d\n", sizeof(*(a + 1)));
8	printf("%d\n", sizeof(&a[0] + 1));
9	printf("%d\n", sizeof(*(&a[0] + 1)));
10	printf("%d\n", sizeof(*a));
11	printf("%d\n", sizeof(a[3]));

注:二维数组数组名表示首元素地址,为第一行的地址。

1.48   数组名单独放在sizeof内部,表示整个数组

2.4     a[0][0]表示第一个元素,又因为类型为int

3.16   a[0]表示第一行的数组名,数组名单独放在sizeof内部,代表这一整行

4.4/8  数组名没有单独放在sizeof内部,所以这里代表数组首元素地址,

5.4     a[0]为第一行的数组名没有单独放在sizeof内部,所以这里就代表首元素地址,+1后为第二个元素的地址,解引用访问,拿到第一行第二个元素,类型为int,因而为4

6.4/8  a为二维数组数组名,没有单独放在sizeof内部,所以表示数组首元素地址,因为是二维数组,首元素的地址为第一行的地址,+1后为第二行的地址,是地址就是4/8

7.16 (a+1)为第二行的地址,解引用拿到第二行;或者可以这么理解:*(a+1) -> a[1] -> 第二行的数组名,单独放在sizeof内部,求的是第二行的大小

8.4/8   a[0]是第一行的数组名,&数组名就是求整个第一行的地址,+1跳过一整行,表示第二行的地址

9.16    对第二行的地址解引用拿到第二行

10.16  a没有单独存在,所以表示数组首元素地址,对其解引用拿到第一行

           还可理解为:*a -> *(a+0) -> a[0]

11.16  sizeof不会访问数组内部,只看类型,a[3]我们知道是不存在的,但是a[2],a[1],a[0]是存在的,其类型一样为int [4] ,所以大小为16

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第16张图片

我们总结一下:我们还是要多多注意数组名是否&和单独放在sizeof内部。

指针笔试题

1. 2,5

int main()
{
  int a[5] = { 1, 2, 3, 4, 5 };
  int *ptr = (int *)(&a + 1);
  printf( "%d,%d", *(a + 1), *(ptr - 1));
  return 0;
}

 解析:

&a+1指向5后面的地址,此时指针类型为int (*) [5],所以需要强制类型转换成int*。

ptr-1,就指向了5的地址,解引用拿到数字5

*(a+1) -> a[1] -> 2

2.

//由于还没学习结构体,这里告知结构体的大小是20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}

我们注意:p为结构体指针,0x表示十六进制数字

p + 0x1加的是一个结构体,而结构体大小为20个字节,所以为:100014

将p转换为整数类型,此时+0x1就是加1,所以为100001

将p转换为unsigned int*型,此时再+1就是跳过一个int,即+4,所以为100004

3. %x是以十六进制进行打印

int main()
{
  int a[4] = { 1, 2, 3, 4 };
  int *ptr1 = (int *)(&a + 1);
  int *ptr2 = (int *)((int)a + 1);
  printf( "%x,%x", ptr1[-1], *ptr2);
  return 0;
}

&a+1指向4后面的地址, 转换成int*类型赋给ptr,ptr[-1]表示ptr的地址向前走1然后访问,即数字4

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第17张图片

然后将其转换成十六进制,进行打印

结果为:4   2000000

4. 

#include 
int main()
{
  int a[3][2] = { (0, 1), (2, 3), (4, 5) };
  int *p;
  p = a[0];
  printf( "%d", p[0]);
return 0;
}

这里是逗号表达式,结果为最后一个表达式 

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第18张图片

 

5.

int main()
{
  int a[5][5];
  int(*p)[4];
  p = a;
  printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
  return 0;
}

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第19张图片 

两地址相减表示地址之间的元素个数,又因为这道题中是低地址减高地址所以为-4,%d打印出来肯定是-4,但是%p就不一定了,我们首先要看补码,

原码:10000000000000000000000000000100
反码:11111111111111111111111111111011
补码:11111111111111111111111111111100

对于%p来说,认为内存中存的是地址,直接把地址打印出来,所以打印的是补码,转换为十六进制为:FFFFFFFC

6.  10,5

int main()
{
  int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  int *ptr1 = (int *)(&aa + 1);
  int *ptr2 = (int *)(*(aa + 1));
  printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
  return 0;
}

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第20张图片

 

7.  at

#include 
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}

 浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第21张图片

 

8.

int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *--*++cpp+3);
printf("%s\n", *cpp[-2]+3);
printf("%s\n", cpp[-1][-1]+1);
return 0;
}

 

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第22张图片

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第23张图片 

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第24张图片 

浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第25张图片 

运行结果:浅学【C语言】之回调函数qsort的模拟实现及指针数组相关习题讲解_第26张图片 

 

你可能感兴趣的:(c语言,开发语言)