【C语言】回调函数 和 部分库函数的用法以及模拟实现

一、回调函数：

1、定义：

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

2、qsort的模拟实现（回调函数的应用）

那么回调函数有什么实际性的作用呢？下面模拟库函数qsort来顺便了解回调函数的用法：（在这里使用冒泡排序来模拟）

首先要了解什么是qsort：

上面的意思是：对数组的元素进行排序，使用函数确定顺序所排序的类型。

依然从代码入手：

int my_cmp(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
 
void Swap(char* buf1, char* buf2, size_t width)
{
	for (size_t i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
Bubble_Sort(void* base,size_t sz,size_t width,int (*cmp)(const void* e1,const void* e2))
{
	for (size_t i = 0; i < sz - 1; i++)
	{
		for (size_t j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
 
void test1()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bobble_Sort(arr, sz, sizeof(arr[0]), my_cmp);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test1();
	return 0;
}

上述代码中：

my_cmp为我要排序整型所需要的函数。

Swap为交换两个元素

Bubble_Sort为冒泡排序模拟库函数qsort

在其中：

if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
    Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);

}

这行代码是最核心的，

width为偏移量，这样可以通过 回调函数来调用my_cmp来知道我是什么类型的和大小。

将传过来的数组名用void* base接收，后来转换为（char*）这样可以+偏移量来找到每个元素，这也是要传数组每个元素的大小的意义。

在Swap函数中与传统的交换不同的是需要每一个元素的大小，这样可以将一个元素以字节为单位一个一个交换，毕竟如果直接交换的话，就会将代码写死（比如写了个int类型，就不能交换浮点数类型）

在上述代码中就在函数中调用了函数，所以就用了回调函数cmp

二、库函数的用法及部分模拟实现：

首先来了解一下有那些处理字符和字符串的库函数：

1、strlen：

这是用来计算字符串长度的。

//计数
int my_strlen1(const char* src)
{
	assert(&src);
 
	int count = 0;
	while (*src++)
		count++;
	return count;
}
//递归
int my_strlen2(const char* src)
{
	assert(src);
	
	if (*src != '\0')
		return 1 + my_strlen2(src + 1);
	else
		return  0;
}
//指针-指针
int my_strlen3(const char* src)
{
	assert(src);
 
	const char* dest = src;
	while (*dest)
	{
		dest++;
	}
	return dest - src;
}
 
int main()
{
	char arr[] = "abcdefg";
	int ret = my_strlen3(arr);
	printf("%d\n", ret);
	return 0;
}

如上用了三种方法分别模拟了字符串长度的计算。

2、strcpy：

这是将一个字符串拷贝到另外一个字符串中的

char* my_strcpy(char* dest, char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
 
int main()
{
	char arr1[] = "abcdefg";
	char arr2[20] = "";
	my_strcpy(arr2, arr1);
	printf("%s\n", arr1);
	printf("%s\n", arr2);
	return 0;
}

在模拟实现中将src一个个赋给dest，最后返回目标数组的地址

3、strcat：

这是将一个字符串追加在另外一个字符串后面。

char* my_strcat(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	//1.找到要追加的地方
	while (*dest)
	{
		dest++;
	}
	//2.追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
 
int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "ppr";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

首先找到我要追加的地方，然后进行赋值即可，最后返回被追加的数组首元素。

4、strcmp：

这是比较两个字符串的大小。

如上，如果第一个字符串小于后一个，那么返回一个小于0 的数；

           如果第一个字符串等于后一个，那么返回0 ；

           如果第一个字符串大于后一个，那么返回一个大于0 的数。

（在VS编译器中分别返回1，0，-1）。

int my_strcmp( char* str1, char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
	//return *str1 - *str2;
}
 
int main()
{
	char arr1[20] = "abqf";
	char arr2[20] = "abqf";
	int ret = my_strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

5、strncpy：

这些长度受限制的函数引入是因为strcpy函数不安全，

比如在strcpy函数中，如果拷贝过去字符串，此时接收这个字符串的数组不够这么大，就会失败，同样，如果c语言中最开始不声明“#define _CRT_SECURE_NO_WARNINGS 1”就会不可以使用，所以就衍生出了strncpy，这个作用和strcpy几乎是一模一样的，就是多了1个无符号整型参数，作用是我要拷贝过来几个字符。

但是strncpy只是相对于strcpy安全罢了，如果你输入的数字等于这个数组的最大元素，那么就会使‘\0’拷贝不过来，也会出现错误：

所以strncpy只是相对于strcpy安全。

6、strncat：

这个多出来的无符号整型的参数就是我需要追加几个字符数。

7、strncmp：

这个多出来的无符号整型的参数就是我需要比较几个字符数。

8、strstr：

这个函数的作用是在一个字符串中找另外一个字符串。

char* my_strstr(const char* src1, const char* src2)
{
	assert(src1 && src2);
	if (*src2 == '\0')
		return (char*)src1;
 
	const char* s1 = src1;
	const char* s2 = src2;
	const char* p= src1;
 
	while (*p)
	{
		s1 = p;
		s2 = src2;
 
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)p;
		p++;
	}
	return NULL;
}
 
int main()
{
	char arr1[] = "abbbbcdef";
	char arr2[] = "bbc";
	char* arr3 = my_strstr(arr1, arr2);
	if (arr3 == NULL)
	{
		printf("找不到\n");
	}
	else 
	{
		printf("%s\n", arr3);
	}
	return 0;
}

思路：

在src1中找src2，第一个while循环将s1，s2分别指向src1和src2的第一位（这样可以使得每次找完可能相等的位置后，如果不相等就会返回此时记录的位置），之后来找可能相等的位置，在第二个while循环中来看看是否相等。

9、strtok：

这是属于一个字符串的分割，

第一个参数为我所需要分割的起始位置，

在后续的调用中在第一个参数位置只需传空指针即可。

第二个参数中传我所分割的标志集合。

10、strerror：

这是一个打印错误信息的函数，C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno（在errno.h这个头文件里面）

错误码是一些数字：1 2 3 4 5

我们需要将错误码翻译成错误信息

int main()
{
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		//perror("fopen");
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	pf = NULL;
	
	return 0;
}

在上面代码中，在当前路径下读一个叫做test.txt的文件，如果没有就会将错误代码打印出来

拓展：有另外一个函数perror这个用起来更加顺手些，将可以函数错误信息直接打印出来。

可以理解为：printf + strerror

11、memcpy：

这个函数也是拷贝，但是不只局限于字符串的拷贝，属于内存的拷贝，

第一个参数是目标拷贝函数，第二个参数是待拷贝的函数，第三个参数是拷贝多少个字节

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 24);
	return 0;
}

模拟实现：

void* my_memcpy(void* dest, void* src, size_t num)
{ 
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
        ++(char*)src;
	}
	return ret;
}
 
 
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 24);
	return 0;
}

我们这个自己模拟的局限性：不能够自我拷贝（但是库函数里的memcpy可以），那么接下来进行优化---------引入了memmove函数的模拟实现

12、memmove：

解决方法：如下图，若src在dest后面，就将src从前往后拷贝，若src在dest前面就从后往前拷贝。

void* my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		//前->后
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
        //后->前
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
 
}
 
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1+2, arr1, 20);
	return 0;
}