[C++知识库]C语言模拟实现常见标准库函数

下面将分别模拟实现memcpy，memmove，strstr，strcat，strcmp，strcpy，strlen

模拟实现memcpy

#include <stdio.h>
#include <string.h>
#include <assert.h>
//void *memcpy( void *dest, const void *src, size_t count );//库函数声明
//dest表示拷贝到哪个目标，src表示拷贝源，加const修饰，防止被修改，count表示拷贝多少个字节
void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);//断言dest和src是否为NULL
	void* ret = dest;//先把dest的地址赋值给ret，以便最后返回
	while (count--)//count--，每次进来先使用再--，为0的时候退出
	{
		//把src的类型强制转换为char*并解引用，赋值给强制转换为char*并解引用的dest
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;//指针+1
		src = (char*)src + 1;//指针+1
	}
	return ret;//返回dest的起始地址
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 2,3,4,5,6,7,8,9,10,11 };
	int i = 0;
	my_memcpy(arr1, arr2, 16);
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

模拟实现memmove

#include <stdio.h>
#include <string.h>
#include <assert.h>
//void *memmove( void *dest, const void *src, size_t count );//库函数声明
//dest表示拷贝到哪个目标，src表示拷贝源，加const修饰，防止被修改，count表示拷贝多少个字节
void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);//断言dest和src是否为NULL
	void* ret = dest;
	//重叠拷贝+不重叠拷贝
	assert(dest && src);
	if (dest < src)
	{
		//前->后
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
		
	}
	else
	{
		//后->前
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	//memcpy只要完成不重叠的内存拷贝就完成任务
	//my_memmove(arr + 2, arr, 16);
	my_memmove(arr, arr + 2, 16);
	//内存拷贝时，出现内存重叠的现象，应该使用memmove
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
}

模拟实现strstr

#include <stdio.h>
#include <assert.h>
//char *strstr( const char *string, const char *strCharSet );//库函数声明
//str1为大的字符串，str2为子字符串
char* my_strstr(const char* str1, const char* str2)
{
	//断言str1，str2是否为NULL
	assert(str1 && str2);
	//创建三个指针变量，作用如上图所示
	const char* s1;
	const char* s2;
	const char* sp = str1;//sp为记录str1的起始位置

	if (*str2 == '\0')//如果*str2为空，则直接返回str1首地址，输出
		return str1;

	while (*sp)//当*sp为'\0'，表示sp已指向str1最后的位置
	{
		s1 = sp;//把sp指向赋给si
		s2 = str2;//把str2起始位置赋给s2
		while (*s1 && *s2 && *s1 == *s2)//当*s1和*s2的值不为'\0'以及*s1和*s2相等进入循环
		{
			s1++;//两个指针向后移动，再继续比较
			s2++;
		}
		if (*s2 == '\0')//如果成立，表示str2就是str1的子字符串
			return sp;//返回sp的地址
		sp++;//sp指针向后移动
	}
	return NULL;//如果程序运行到这里，表示str2不是str1的子字符串，则返回NULL
}
int main()
{
	char str1[] = "Do the right thing at the right time";
	char str2[] = "right";
	char* ret = my_strstr(str1, str2);
	if (NULL == ret)
		printf("找不到\n");
	else
		printf("%s\n", ret);
	
	return 0;
}

模拟实现strcat

#include <stdio.h>
#include <assert.h>
//char *strcat( char *strDestination, const char *strSource );//库函数声明
//dest表示追加字符的目标，src表示要追加的字符串，用const修饰，防止被修改
char* my_strcat(char* dest, const char* src)
{
	//判断dest和src是否为NULL
	assert(dest && src);
	//把dest的起始位置赋值给ret，以便返回
	char* ret = dest;
	while (*dest)//当*dest不为'\0'，进入循环
	{
		dest++;//dest指针向后移动
	}
	//此时dest的指针已指向最后一个位置
	while (*dest++ = *src++)//循环追加字符
	{
		;
	}

	return ret;
}
int main()
{
	char str1[20] = "I am ";
	char str2[] = "zhao";
	my_strcat(str1, str2);
	printf("%s\n", str1);
	return 0;
}

模拟实现strcmp

#include <stdio.h>
#include <assert.h>
//int strcmp( const char *string1, const char *string2 );//库函数声明
//str1和str2表示要对比的字符串，因为不需要修改内容，所以都加const修饰
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1, str2);//判断str1和str2是否为NULL
	while (*str1 == *str2)//如果*str1和*str2相等，进入循环
	{
		if (*str1 == '\0')//如果str1的值为'\0'，表示两个字符串相等
			return 0;
		str1++;//指针向后移动
		str2++;
	}
	return *str1 - *str2;//如果两个字符串不相等，则返回它们的差值
}
int main()
{
	char str1[] = "abcdeg";
	char str2[] = "abcdef";
	int ret = my_strcmp(str1, str2);
	if (0 > ret)
		printf("<\n");
	else if (0 < ret)
		printf(">\n");
	else
		printf("=\n");
	
	return 0;
}

模拟实现strcpy

#include <stdio.h>
#include <assert.h>

//char *strcpy( char *strDestination, const char *strSource );//库函数声明
//dest表示拷贝的目标，src表示拷贝的源，因为源不需要修改，所以const修饰
char* my_strcpy(char* dest, const char* src)
{
	//判断dest和src是否为空
	assert(dest && src);
	//dest的起始位置赋给ret
	char* ret = dest;

	while (*dest++ = *src++)//源赋值给目标，源目标指针向后移动
	{
		;
	}

	return ret;
}
int main()
{
	char str1[] = "at the not same";
	char str2[] = "at the same!!!";
	char* ret = my_strcpy(str1, str2);
	printf("%s\n", ret);
	perror("test:");
	return 0;
}

模拟实现strlen

#include <stdio.h>
#include <assert.h>
#include <string.h>

//size_t strlen( const char *string );//库函数声明
//str表示要计算的字符串，用const修饰，返回值为无符号的int
//1.计数器
size_t my_strlen(const char* str)
{
	//判断str是否为NULL
	assert(str);
	size_t count = 0;//创建计数变量
	while (*str)
	{
		str++;
		count++;
	}
	return count;
}
//2.递归
size_t my_strlen(const char* str)
{
	//判断str是否为NULL
	assert(str);
	if (*str)//如果*str不等于'\0'
	{
		str++;//str指针向后移动
		return 1 + my_strlen(str);
	}
	else
		return 0;
}

//3.指针
size_t my_strlen(const char* str)
{
	char* p = str;//把str的起始地址赋值给char*类型的指针变量p
	while (*str)//当*str不为'\0'，进入循环
	{
		str++;
	}
	return str - p;//返回首尾指针的差值
}

int main()
{
	char str[] = "Today is a good day !";
	size_t len = my_strlen(str);
	printf("%d\n", len);
	perror("test:");
	return 0;
}