2022.4.19 关于字符串函数介绍

茂大师

已于 2023-10-17 19:45:54 修改

阅读量397

点赞数 2

分类专栏： C语言文章标签： c语言

于 2022-04-19 21:26:11 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_63888301/article/details/124145123

版权

C语言专栏收录该内容

14 篇文章 0 订阅

订阅专栏

目录

strlen函数的模拟实现

模拟实现strcpy

模拟实现strcat

模拟实现strcmp

关于strncpy的模拟实现

关于strncat的模拟实现

关于strncmp的模拟实现

关于模拟实现strstr的模拟实现

strlen

size_t strlen ( const char * str );

用途：计算字符串的长度

该函数以字符串的 '\0' 作为结束标志，返回字符串中 '\0' 前出现的字符个数且不包括 '\0' 本身

注意：size_t 为无符号的整型，所以strlen返回的值为无符号的整型！

举例1：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	if (strlen("abc") - strlen("qwerty") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");
	}
	return 0;
}
输出结果为：

解释如下：

我们根据strlen函数的定义可知，strlen返回值为一个无符号的整型，所以两个无符号的数相减还是无符号的数，从而 3 - 6 为 -3 ，此时的 -3 为无符号数，从而符号位被理解为数据位，从而转化成了一个很大的正整数，从而大于零。

（对此不理解的伙伴可以参考我之前发的文章数据的存储，里面介绍十分详细！）

举例2：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr[] = "abcdef";
	int ret = strlen(arr);
	printf("%d\n", ret);
	return 0;
}
输出结果为：

解释如下：（我们打开监视查看我们定义的字符数组中所存储的内容）

我们发现我们所定义的字符数组中自动给字符串的最后加上了 '\0'，从而我们strlen能够很好的算出该字符串的大小。

举例3：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr[] = { 'a','b','c','d' };
	int ret = strlen(arr);
	printf("%d\n", ret);
	return 0;
}
输出结果为：（该输出结果为随机值）

解释如下：（我们打开监视查看我们定义的字符数组中所存储的内容）

我们可以发现数组中并没有存储 '\0' ，从而strlen便会越界访问一直向后计算长度，直至遇到值为0的时候（就是 '\0' ），从而结束计算长度，我们并不知道 '\0' 在哪会出现，这是预测不到的，从而打出来的值为随机值。

改进方案：

可在该字符数组后手动添加 '\0' ，或者直接规定数组的大小，如果该数组并未存满，便会自动以 '0' 来初始化填充该字符数组。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
    char arr1[10] = { 'a','b','c','d' }; //直接指定数组大小
	char arr2[] = { 'a','b','c','d','\0'}; //手动填充'\0'
	int ret1 = strlen(arr1);
	int ret2 = strlen(arr2);
	printf("ret1=%d\n", ret1);
	printf("ret2=%d\n", ret2);
	return 0;
}
输出结果为：

strlen函数的模拟实现
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>

size_t my_strlen(const char* ptr) //加const修饰，使得数组的内容不会发生改变
{
	assert(ptr);//断言一下，以免出来的数组为空指针，从而可以直接报错
	int count = 0;
	while (*(ptr++) != '\0')
	{
		count++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdef";
	int ret =my_strlen(arr);
	printf("ret=%d\n", ret);
	return 0;
}
输出结果为：

strcpy

char * strcpy ( char* destination, const char* source );

用途：将一字符串拷贝到另一字符串中

使用该函数时，源字符串必须以 ' \0 ' 结尾，并且会将源字符串的 ' \0 ' 拷贝到目标字符串空间，与此同时还要保证目标字符串的空间要够大，且可被修改！

举例1：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[15] = { 0 };
	char arr2[] = { 'a','b','c' };
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}
输出结果为：（程序崩溃）

解释如下：

我们的源字符串 arr2 并未直接给定一个 ' \0 ' ，所以我们的 strcpy 函数便会越界从而导致程序的崩溃。

改进方法：

同 strlen 函数例3的改进方法。

举例2：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "XXXXX";
	char arr2[] = "abcdefg";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}
输出结果为：（程序报错）

解释如下：

这里很明显是我们没有预先给定其目标空间的大小，只是初始化了几个字符，从而导致我们的目标空间不够大，进而无法存下源字符串的内容，从而发生报错。

改进方法：

预先给定目标空间一个比源字符串要大的大小。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[10] = "XXXXX";
	char arr2[] = "abcdefg";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}
输出结果为：（正常且无报错）

模拟实现strcpy
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strcpy(char* dest, const char* sour) 
{
	assert(dest && sour);
	char* str = dest;
	while (*(dest++)=*(sour++)) // 源字符串拷贝到目标空间，直至拷贝完源字符串'\0'为止
	{
		;
	}
	return str;

}

int main()
{
	char arr1 [] = "abcdef";
	char arr2 [] = "hello";
	char* began =my_strcpy(arr1, arr2);
	printf("%s\n", began);
	return 0;
}
输出结果为：

strcat

char * strcat ( char* destination, const char* source );

用途：将一字符串开头连接到另一字符串末尾处

使用该函数时，源字符串必须以 ' \0 ' 结尾，与此同时还要保证目标字符串的空间要够大，且可被修改且以 '\0' 结尾！

举例1：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[20] = "hello";
	char arr2[] = "world";
	char* began=strcat(arr1, arr2);
	printf("%s\n", began);
	return 0;
}
打开监视观察arr1字符数组使用strcat的前后变化：

strcat前：

strcat后：

我们可以发现目标空间所存储的字符串其 '\0' 直接被源字符串的首字符所替代，且所产生的新 '\0' 是由源字符串所带来的！

模拟实现strcat
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strcat(char* dest, const char* sour) //加上const修饰，可以防止源字符串被修改
{
	assert(dest && sour); // 断言一下，以免出来的数组为空指针，从而可以直接报错
	char* str = dest;
	while (*(++dest) != '\0') //找到目标空间字符串 '\0' 的位置
	{
		;
	}
	while (*(dest++) = *(sour++)) // 源字符串拷贝到目标空间，直至拷贝完源字符串'\0'为止
	{
		;
	}
	return str;
}

int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	char* began=my_strcat(arr1, arr2);
	printf("%s\n", began);
	return 0;
}
输出结果为：

strcmp

int strcmp(const char*str1,const char*str2);

用途：用于两个字符串之间的比较

标准规定

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

举例1：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "wang";
	char arr2[] = "wen";
	int ret=strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}
输出结果为：

我们可以由输出结果得知，strcmp函数在进行字符串的比较时，并不是比较两个字符串的长度，而是从首字符开始，比较相对应位置上的字符大小，相同便比较下一对，直到不相同为止！

模拟实现strcmp
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>

int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1==*s2)
	{
		if (*s1 =='\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	return (*s1 - *s2);
}

int main()
{
	char arr1[] = "abcq";
	char arr2[] = "abc";
	int ret = my_strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}
输出结果为：（返回大于0的数）

strncpy

char * strncpy (char * destination , const char * source , size_t num)

用途：拷贝 num 个字符从源字符串到目标空间

标准规定：

如果源字符串的长度小于 num，则拷贝完源字符串之后，在目标的后面追加0，直到 num个

举例1：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "XXXXX";
	char arr2[] = "abc";
	strncpy(arr1, arr2,4);
	printf("%s\n", arr1);
  return 0;
}
打开监视观察arr1字符数组使用strncpy的前后变化：

strncpy前：

strncpy后：

输出结果为：

关于strncpy的模拟实现
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strncpy(char*ptr1, const char*ptr2, size_t count) // size_t 是无符号整型类型
{
	assert(ptr1 && ptr2); // 断言一下，以免传入空指针
	char* tmp = ptr1;
	for (int i = 0; i < count; i++) //开始一个一个对应复制
	{
		if (*ptr2 == '\0') // 如果源字符串的长度不够 便需要用 0 来填充剩下的长度
		{
			*ptr1 = 0;
			ptr1++;
		}
		else //这里便是对应复制的操作
		{
			*ptr1 = *ptr2;
			ptr1++;
			ptr2++;
		}
	}
		return tmp;
}

int main()
{
	char arr1[] = "abcde";
	char arr2[] = "gh";
	char* began = my_strncpy(arr1, arr2, 4);
	printf("%s\n",began);
	return 0;
}
输出结果为：

strncat

char * strncpy (char * destination , const char * source , size_t num)

用途：：将一字符串从开头开始计数的num个字符连接到另一字符串末尾处

举例1：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[25] = "abcde\0XXXX";
	char* began = strncat(arr1, arr1, 3);
	printf("%s\n", began);
	return 0;
}

打开监视观察arr1字符数组使用strncat的前后变化：

strncat前：

strncat后：

输出结果为：

关于strncat的模拟实现

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

char* my_strncat(char* ptr1, const char* ptr2, size_t count)
{
	assert(ptr1 && ptr2);
	char* tmp = ptr1;
	while (*ptr1 != '\0') //寻找到目标空间字符串的结束符号'\0'
	{
		ptr1++;
	}
	for (int i = 0; i < count; i++) //从目标空间结束符开始不断追加
	{
		*ptr1 = *ptr2;
		ptr1++;
		ptr2++;
	}
	*ptr1 = '\0'; //追加完后手动给目标空间的字符串末尾加上一个字符串结束符
	return tmp;
}

int main()
{
	char arr1[25] = "abcde\0XXXX";
	char arr2[10] = "fghijk";
	char* began = my_strncat(arr1, arr2, 3);
	printf("%s\n", began);
	return 0;
}

输出结果为：

strncmp

int strcmp (const char * str1,const char * str2，size_t count);

用途：用于两个字符串从开头开始计数num个对应字符的比较

关于strncmp的模拟实现

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

int my_strncmp(const char* s1, const char* s2, size_t count)
{
	assert(s1 && s2);
	for (int i = 0; i < count; i++) // 需要 对应位置比较的 次数
	{
		if (*s1 == *s2) // 如果在比较的对应位置 是相等的 进入下一步判定
		{
			if (*s1 == '\0') // 这里是如果是在对应位置，且对应位置为 '\0' 时，此时相互比较的两字符串是相等的 自然返回0
				return 0;  
			s1++;  // 既然在此位置，两字符串的字符相等 那这里的两个指针变量便自增 从而进行下一个位置的比较
			s2++;
		}
		else //既然对应位置的字符 不相同 ，此时便可直接比较两字符的大小 ，从而返回值便是两字符串的大小 比较结果
			return (*s1 - *s2);
	}
	return 0; // 如果我们要比较对应位置的次数比较完了， 代表两字符串count之前的位置字符串是相等的 且没有出现 '\0' 便意味着两字符串需比较部分的字符串是相等 从而直接返回0  
}

int main()
{
	char arr1[] = "abcdf";
	char arr2[] = "abce";
	int ret = my_strncmp(arr1, arr2,3);
	printf("%d\n", ret);
	return 0;
}

输出结果为：

strstr

char * strstr(const char * str1, const char * str2);

用途：用于查找一字符串中是否为另一字符串的子串

标准规定：

若找得到子串则返回母串中所找到的该子串的地址

若找不到则返回空指针NULL

举例1：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcdeqabcdefg";
	char arr2[] = "cdef";
	char* ret = strstr(arr1, arr2);
	if (NULL == ret)
	{
		printf("找不到子串\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}
输出结果为：

关于模拟实现strstr的模拟实现

该函数的模拟实现相对较难我们可以将思路理清：

可以先在母串上创建两个指针变量 s1 和 cur ，再在子串上创建一个指针变量 s2 ，s1 和 s2用来两字符串字符的比较同时我们要注意一个问题，当我们 s1 和 s2 两个相互比较时且在s2指向子串的 '\0' 之前，两个指针所指向的字符不相等时，我们的 s2 便需要重新回到子串的头字符，我们 s1 便需要重新回到母串我们所开始比较的与子串头字符相等那个字符的后面一个字符，重新开始我们的子串匹配。此时我们的 cur 便是用作记录 s2开始比较的与子串头字符相等的地址，以便 s2 重新开始下一轮的与 s1 的对应比较。

举例：如上图母串 abbcdf 我们 s1 找到与子串头字符相等的字符 b 我们的 cur 同时记录该字符的地址，记录我们子串 bcd 头字符地址的 s2 便开始与 s1 进行对应比较相同便一起自增来比较下一个字符是否相等但是我们的 s1 指向的下一个字符还是 b 但是我们 s2 所指向的下一个字符是 c 此时便不相等我们的 s1 便回到我们 cur 所指向的 b 的下一个字符，cur 同时也随而指向 b 的下一个 s1 所开始比较的字符，s2便再回到子串的头字符，从而进行下一轮的比较。

当我们的 s1 与 s2 所指向的字符且随着他们两的自增一直相等时，直到 s2 指向子串最后的 '\0' ，我们便从母串中寻找到了我们的子串从而直接返回 cur 的地址！若当我们的 cur 一直指向我们母串的 '\0' ，则代表在我们的母串中，没有找到其子串，从而返回 NULL。

根据我们的思路写出的代码如下：
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	char* s1 = str1; 
	char* s2 = str2;

	char* cur = str1;
	while (*cur != '\0')
	{
		s1 = cur;
		s2 = str2;
		while ((*s1 == *s2)&&(*s1!='\0')&&(*s2 != '\0')) 
		{
			s1++;
			s2++;

		}
		if (*s2 == '\0')
		{
			return cur;
		}
		cur++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abcdeqabcdefg";
	char arr2[] = "cdef";
	char* ret = my_strstr (arr1, arr2);
	if (NULL == ret)
	{
		printf("找不到子串\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}
输出结果为：

以上便是关于字符串函数的全部内容！

如有错误或者能改进的地方请各大佬指出我会及时改正！！

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
2022.4.19 关于字符串函数介绍

strlensize_t strlen( const char * str );该函数以字符串的 '\0' 作为结束标志，返回字符串中 '\0' 前出现的字符个数且不包括 '\0' 本身注意：size_t 为无符号的整型，所以strlen返回的值为无符号的整型！举例1：#define _CRT_SECURE_NO_WARNINGS#include<stdio.h>#include<string.h>int main(){ char arr[] ...
复制链接

扫一扫

专栏目录

博客等级

码龄3年

Java领域新星创作者

133
原创

1487
点赞

1433
收藏

2385
粉丝

关注

私信

热门文章

分类专栏

SpringCloud 6篇
测试开发 14篇
环境配置 7篇
模拟实现 RabbitMQ 11篇
mysql 3篇
Redis 26篇
C语言 14篇
数据结构UP 1篇
Java 基础 4篇
Spring 24篇
云服务器 1篇
JVM 2篇
网络 8篇
三子棋 1篇
多线程 14篇
扫雷 1篇
文件IO 2篇

最新评论

2024.5.22 关于 SpringCloud —— Nacos 配置管理
CSDN-Ada助手: 不知道 Java 技能树是否可以帮到你：https://edu.csdn.net/skill/java?utm_source=AI_act_java
2024.5.6 关于 SpringCloud 的基本认知
2401_84584289: 这篇文章是优质之作，内容充实，结构明晰，语言流畅且通俗易懂，适合广大读者阅读。【我也写了一些相关领域的文章，希望能够得到博主的指导，共同进步！】
2024.2.23 模拟实现 RabbitMQ —— 实现消费消息逻辑
白话机器学习: 内容丰富图文并茂，认真看完收获很大。思路清晰细节满满，支持大佬优质好文。
2024.2.21 模拟实现 RabbitMQ —— 实现转发规则
白话机器学习: 通过文章可以看出，博主很有耐心，技术文章不仅是对技术的坚守，更是对知识的热忱和热爱，感谢您的优质分享和坚持更文。期待着博主更加深入的剖析，为大家带来更多的技术好文。
2023.1.15 关于 Redis 持久化 RDB 策略详解
全栈小5: 通过文章可以看出，博主很有耐心，技术文章不仅是对技术的坚守，更是对知识的热忱和热爱，感谢您的优质分享和坚持更文。期待着博主更加深入的剖析，为大家带来更多的技术好文。【2023.1.15 关于 Redis 持久化 RDB 策略详解，博主这篇文章，值得一看】

最新文章

目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

打赏作者

茂大师 你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

扫码支付：¥1

获取中

扫码支付

您的余额不足，请更换扫码支付或充值

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。