【详解库函数】C语言——字符函数和字符串函数的部分模拟实现

#include <stdio.h>
int main()
{
     const char*str1 = "abcdef";
     const char*str2 = "bbb";
 if(strlen(str2)-strlen(str1)>0)
     {
         printf("str2>str1\n");
     } 
 else
     {
         printf("srt1>str2\n");
     }
     return 0;
}

这里我们的常规思路应该是str2的长度-str1的长度那就是3-6=-3，应该走if的选项，可是我们运行起来，却不是我们想要的答案，这是因为strlen函数的返回类型是size_t,是一个无符号的整数，这里就需要大家注意一下，避免搞错了哟。

3，模拟实现

常规：

size_t my_strlen(char* str) 
{
	assert(str);
	int count = 0;
	while (*str != '\0') 
	{
		str++;
		count++;
	}
	return count;
}
int main() 
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d", ret);
}

递归：

size_t my_strlen(char* str) 
{
	assert(str);
	while (*str != '\0') 
	{
		return 1 + my_strlen(str + 1);
	}
}
int main() 
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d", ret);
}

指针-指针：

size_t my_strlen(char* str) 
{
	assert(str);
	char* src = str;
	while (*str != '\0') 
	{
		str++;
	}
	return str - src;
}
int main() 
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d", ret);
}

以上小编针对strlen这个函数的模拟实现提供了三种方法，大家都可以去试一试哟，你还有什么办法，可以在评论区留言哟。

二，长度不受限制的字符串

1.1，函数介绍-strcpy

2.1，注意事项

1，源字符串必须要以'\0'结尾。

2，目标空间必须足够大，要能够存放下源字符串。

3，会将源字符串中的'\0'拷贝过去。

4，目标空间必须是可变的。

3.1，模拟实现

char* my_strcpy(char* dest, const char* str) 
{
	assert(dest && str);
	char* ret = dest;
	while (*dest++ = *str++) 
	{
		;
	}
	return ret;
}
int main() 
{
	char arr1[] = "abcdef";
	char arr2[10] = { 0 };
	char* ret = my_strcpy(arr2, arr1);
	printf("%s", ret);
}

1.2，函数介绍strcat

2.2，注意事项

1，源字符串必须以'\0'结尾。

2，目标空间必须足够打，能够存放下源字符串。

3，目标空间必须可修改。

3.2，模拟实现

char* my_strcat(char* dest, const char* str) 
{
	assert(dest && str);
	char* ret = dest;
	//先找'\0'
	while (*dest != '\0') 
	{
		dest++;
	}
	//追加
	while (*dest++ = *str++) 
	{
		;
	}
	return ret;
}
int main() 
{
	char arr1[20] = "hello ";
	char arr2[] ="world";
	char* ret = my_strcat(arr1, arr2);
	printf("%s", ret);
}

1.3，函数介绍-strcmp

2.3，注意事项

3.3，模拟实现

int my_strcmp(const char* str1, const char* str2) 
{
	assert(str1 && str2);
	while (( * str1 - *str2==0)&&*str1)
	{
		++str1;
		++str2;
	}
	return *str1 - *str2;
}
int main() 
{
	char arr1[20] = "abcd";
	char arr2[] ="abcz";
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
}

三，长度受限制的字符串

1.1，函数介绍-strncpy

1.2,注意事项

1，将num个源字符串的字符拷贝到目标空间

2，如果源字符串的长度小于num，则将源字符串拷贝完成后，在目标的空间后追加0，直到num个。

1.3，模拟实现

char* my_strncpy(char* dest, const char* str, size_t num) 
{
	assert(dest && str);
	char* ret = dest;

	while (num--) 
	{
		*dest++ = *str++;
	}
	return ret;
}
int main() 
{
	char arr1[20] = "a bm A";
	char arr2[] ="I a";
	char* ret=my_strncpy(arr1, arr2,3);
	printf("%s", ret);
}

2.1，函数介绍-strncat

2.3，模拟实现

char* my_strncat(char* dest, const char* str, size_t num) 
{
	assert(dest && str);
	char* ret = dest;
	while (*dest) 
	{
		dest++;
	}
	while (num--) 
	{
		*dest++ = *str++;
	}
	return ret;
}
int main() 
{
	char arr1[20] = "hello ";
	char arr2[] ="world";
	char* ret = my_strncat(arr1, arr2, 3);
	printf("%s", ret);
}

3.1，函数介绍-strncmp

3.3，模拟实现

int my_strncmp(char* dest, const char* str, size_t num) 
{
	assert(dest && str);
	while (*dest == *str && *dest * --num) 
	{
		dest++;
		str++;
	}
	return *dest - *str;
}
int main() 
{
	char arr1[20] = "abcdef";
	char arr2[] ="abcdzf";
	int ret = my_strncmp(arr1, arr2, 4);
	if (ret > 0)
		printf(">\n");
	else if (ret < 0)
		printf("<\n");
	else
		printf("=\n");
}

字符串是有差异的，但是小编这里只是判断前四个，所以是相等的哟。

四，字符串查找

1.1，函数介绍-strstr

1.2，模拟实现

思路：

这里我们可以分为两种情况，第一种：直接就匹配成功的，这个很简单，第二种：需要匹配多次，比如我们下面这种情况（见下图），需要匹配多次才可以成功。那我们要怎么做呢，我们分析一下：首先我们要判断一下这个字串是不是空串，如果是就没有找的必要了，如果不是我们在开始寻找；如果我们的首字符不相等，那是不是应该str1++,去寻找下一个呢，如果我们发现相等，应该两个字符串一起向后走，去比较下一个，如果匹配失败了，str2是不是应该回到起始地址重新匹配呢？而str1是不是应该回到第一次匹配成功的下一个字符的地址开始匹配呢？（因为第一次匹配成功后再往下匹配就失败了，所以从第一次的那个地址开始是找不到，str2这个字串的，应该去到他的下一个字符的地址，重新开始匹配）,但是很遗憾，str1第一次匹配成功的地址我不知道，str2的起始地址我也不知道，所以我们就应该想到，这个两个指针是不可以亲自，往后走的，应该找两个代替他们的指针，而且还需要记住每一次匹配成功但往后匹配失败时的第一个字符的地址，因为需要让他去到下一个地址，那我们以及分析好了，那就直接上代码吧。

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	char* s1 = NULL;
	char* s2 = NULL;
	char* pc = str1;
	while (*pc)
	{
		s1 = pc;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) 
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0') 
		{
			return pc;
		}
		pc++;
	}
	return NULL;
}
int main() 
{
	char arr1[20] = "abbbcdef";
	char arr2[] ="bbc";
	char* ret = my_strstr(arr1, arr2);
	printf("%s", ret);
}

2.1，函数介绍-strtok

2.2，注意事项

1，delimiters参数是一个字符串，定义了用作分隔符的集合。

2，strtok函数找到str中的下一个标记，并将其用'\0'结尾，返回一个指向这个标记的指针（strtok函数会改变被操作的字符串，所以使用strtok函数切割的字符串，一般都是临时拷贝的内容并且可修改）。

3，strtok函数的第一个参数不为NULL，函数找到str中的第一个标记，并将保存他在在字符串中的位置。

4，strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

5，如果字符串中不存在更多的标记，则返回空指针。

五，错误信息报告

1，函数介绍-strerror

返回错误码所对应的信息

六，内存操作函数

1.1，函数介绍-memcpy

1.2,注意事项

1，函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

2，这个函数在遇到 '\0' 的时候并不会停下来。

3，如果source和destination有任何的重叠，复制的结果都是未定义的。

1.3，模拟实现

void * memcpy ( void * dst, const void * src, size_t count)
{
   void * ret = dst;
   assert(dst&&src);
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
       }
        return(ret);
}

2.1,函数介绍-memmove

2.2，注意事项

1,和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

2,如果源空间和目标空间出现重叠，就得使用memmove函数处理。

2.3,模拟实现

void * memmove ( void * dst, const void * src, size_t count)
{
        void * ret = dst;
        if (dst <= src || (char *)dst >= ((char *)src + count)) {
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
               }
       }
        else {
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
               }
       }
        return(ret);
}

逆风微笑的代码狗qaq

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【详解库函数】C语言——字符函数和字符串函数的部分模拟实现

本篇文章的重点在于介绍处理字符，字符串的函数的使用以及注意事项，还有部分函数的模拟实现。1，源字符串必须要以'\0'结尾。2，目标空间必须足够大，要能够存放下源字符串。3，会将源字符串中的'\0'拷贝过去。4，目标空间必须是可变的。1，源字符串必须以'\0'结尾。2，目标空间必须足够打，能够存放下源字符串。3，目标空间必须可修改。++str1;++str2;int main()1，将num个源字符串的字符拷贝到目标空间。
复制链接

扫一扫