常见字符串函数解析+模拟实现——C语言

目录

一、strlen

二、strcpy

三、strcmp

四、strcat 

五、strstr 

六、memcpy 

七、memmove


一、strlen

//strlen的函数声明
size_t strlen(const char *str)

        我们知道strlen函数用来计算字符串 str 的长度的,但是有些细节我们需要注意:

        1:字符串已经 '\0' 作为结束标志,strlen函数返回的是在字符串中 '\0' 前面出现的字符个数(不包含 '\0' )

        2:参数指向的字符串必须要以 '\0' 结束;没有 '\0' 结束的话strlen会接着往下计算,直至内存中某处出现'\0'(这时strlen返回的值是随机值)。

        3:注意函数的返回值为size_t,是无符号的。

strlen的模拟实现:

#define _CRT_SECURE_NO_WARNINGS

//模拟实现strlen
#include <stdio.h>
//当我们不需要改变指针指向的字符串内容时,最好在指针前加const
size_t my_strlen(const char* str)
{
	int count = 0;
	while (*str != '\0')//当指针指向'\0'就会停止计算
	{
		str++;
		count++;
	}
	return count;
}
int main()
{
	char ch[100] = { 0 };//不写下标则会报错——这会导致指针访问数组时越界
	//ERR:Run-Time Check Failure #2 - Stack around the variable 'xxx' was corrupted

	scanf("%s", ch);
	int ret = my_strlen(ch);
	printf("%d", ret);
	return 0;
}

运行结果:

二、strcpy

//strcpy的声明 
char *strcpy(char *dest, const char *src);

C 库函数strcpy把 src 指针所指向的字符串复制到 dest 数组。

需要注意的是:

1、如果目标数组 dest 不够大,而src字符串的长度又太长,可能会造成缓冲溢出的情况。

2、src字符串必须以 '\0' 结束,且strcpy会将src字符串中的 '\0' 拷贝到目标空间。

3、目标空间必须可变,若目标空间为常量就没办法实现strcpy。

模拟实现strcpy:

//模拟实现strcpy
char* my_strcpy(char* ch, const char* ch2)
{
	char* ret = ch;
	while (*ch2 != '\0')
	{
		*ch = *ch2;
		ch++;
		ch2++;
	}
	return ret;
}

int main()
{
	char ch[100] = { 0 };
	char ch2[20] = { 0 };
	printf("请输入拷贝内容:\n");
	scanf("%s", &ch2);
	my_strcpy(ch, ch2);
	printf("拷贝内容为:\n");
	printf("%s", ch);
	return 0;
}

运行结果:

 三、strcmp

//strcmp的声明
int strcmp(const char *str1, const char *str2);

C 库函数strcmp把 str1 所指向的字符串和 str2 所指向的字符串进行比较,并返回某一数值。

其中有两个参数str1str2 :str1 -- 要进行比较的第一个字符串。str2 -- 要进行比较的第二个字符串。

该函数返回值如下:

  • 如果返回值小于 0,则表示 str1 小于 str2。
  • 如果返回值大于 0,则表示 str1 大于 str2。
  • 如果返回值等于 0,则表示 str1 等于 str2。

那它是如何比较两个字符串的?

两个字符串自左向右逐个字符相比(按 ASCII 值大小相比较),直到出现不同的字符或遇 '\0' 为止; 以"abcdef" 和 "ABCDEF" 两个字符串为例比较,显然左边字符串的ASCII值是大于右边的ASCII值,最后strcmp会返回正值以表示左边字符串比右边字符串大。

模拟实现strcmp:

//
//模拟实现strcmp
int my_strcmp(const char* str1, const char* str2)
{
	while (*str1 == *str2)//若指向的字符相等则继续往下读,直到出现指向不同的字符
	{
		if (*str1 == '\0')
			break;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

int main()
{
	char str1[] = "ab";
	char str2[] = "abc";
	int ret = my_strcmp(str1, str2);
	printf("%d", ret);//正数表示str1大于str2,负数表示str1小于str2,0表示两者相等
	return 0;
}

运行结果:

四、strcat 

//strcat的声明
char *strcat(char *dest, const char *src);

C 库函数strcat把 src 所指向的字符串追加到 dest 所指向的字符串的结尾,其中有两个参数destsrcdest -- 指向目标数组,该数组包含了一个 C 字符串,且足够容纳追加后的字符串;src -- 指向要追加的字符串,该字符串不会覆盖目标字符串。最后strcat会返回一个指向最终的目标字符串 dest 的指针。

这里需要注意的是:

1、src字符串必须以 '\0' 结束。

2、目标空间必须有足够的大,能容纳下源字符串的内容。

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

4、不可用strcat使字符串自己给自己追加内容,会陷入死循环。

模拟实现strcat:

//模拟实现strcat
char* my_strcat(char* ch1, const char* ch2)
{
	char* ret = ch1;
	while (*ch1)
	{
		ch1++;
	}
	while (*ch1++ = *ch2++)
	{
		;
	}
	return ret;
}

int main()
{
	char ch1[100] = "xxxx";
	char ch2[100] = "abc";
	//不写下标则会报错——这会导致指针访问数组时越界
	//ERR:Run-Time Check Failure #2 - Stack around the variable 'xxx' was corrupted
	my_strcat(ch1, ch2);
	printf("%s", ch1);
	return 0;
}

运行结果:

五、strstr 

//strstr的声明
char *strstr(const char *haystack, const char *needle);

        C 库函数strstr可在字符串 haystack 中查找第一次出现字符串 needle 的位置,不包含终止符 '\0'。其中有两个参数——haystack -- 要被检索的 C 字符串,needle -- 在 haystack 字符串内要搜索的小字符串。

        若函数strstr在字符串 haystack 中找到第一次出现字符串 needle 的位置,则该函数会返回在 haystack 中第一次出现 needle 字符串的位置,如果未找到则返回 null。

模拟实现strstr:

//模拟实现strstr
char* my_strstr(const char* str1, const char* str2)
{
	const char* cur = str1;
	const char* ch1 = str1;
	const char* ch2 = str2;
	if (*ch1 == '\0' || *ch2 == '\0')
	{
		return ch1;
	}
	while (*ch1 != '\0' && *ch2 != '\0' && (*ch1 == *ch2))
	{
		ch1++;
		ch2++;
		if (*ch2 == '\0')
		{
			return (char*)cur;
		}
	}
	return NULL;
}

int main()
{
	char ch1[100] = "abcdef";
	char ch2[100] = "abcd";

	char* p = my_strstr(ch1, ch2);

	if (*p != NULL)
		printf("%s", my_strstr(ch1, ch2));//找到了
	else
		printf("不存在\n");//没找到
	return 0;
}

运行结果:

六、memcpy 

//memcpy的声明
void *memcpy(void *str1, const void *str2, size_t n);

C 库函数memcpy从存储区 str2 复制 n 个字节到存储区 str1。最后该函数将会返回一个指向目标存储区 str1 的指针。

这其中有三个参数:str1 -- 指向用于存储复制内容的目标数组,类型强制转换为 void* 指针;str2 -- 指向要复制的数据源,类型强制转换为 void* 指针;n -- 要被复制的字节数。

这里需要注意的是:

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

2、如果sourcedestination有任何的重叠,复制的结果都是未定义的。

模拟实现memcpy:

//模拟实现memcpy
#include <stdio.h>
#include <string.h>
#include <assert.h>

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;

	assert(dest);
	assert(src);

	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src  = (char*)src + 1;
	}
	return ret;
}

int main()
{
	char ch1[100] = { 0 };
	char ch2[] = "abcdef";
	my_memcpy(ch1, ch2, strlen(ch2)+1);
	printf("%s", ch1);
	return 0;
}

运行结果:

七、memmove

//memmove的声明
void *memmove(void *str1, const void *str2, size_t n);

 C 库函数memmove从 str2 复制 n 个字符到 str1;虽然功能与memcpy相似,但是如果源空间和目标空间出现重叠,就得使用memmove函数处理。也就是说它和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

//模拟实现memmove

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

void* my_memmove(void* dest, const void* src,size_t num)
{
	void* cur = dest;

	assert(dest);
	assert(src);

	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);
		}
	}
	return cur;
}

int main()
{
	char ch1[100] = "you are XXXX beautiful!lol";
	char ch2[] = "very";
	my_memmove(ch1+8, ch2, 4);
	printf("%s", ch1);
	return 0;
}

运行结果

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: C语言中常用的字符串替换函数是`str_replace`,它可以在一个字符串中查找并替换指定的子字符串。下面我将简单地模拟实现一个`str_replace`函数。 ```c #include <stdio.h> #include <stdlib.h> #include <string.h> char* str_replace(const char* str, const char* search, const char* replace) { char* result; int search_len = strlen(search); int replace_len = strlen(replace); int count = 0; // 统计需要替换的次数 const char* s = str; while ((s = strstr(s, search)) != NULL) { count++; s += search_len; } // 计算替换后的字符串长度 int result_len = strlen(str) + count * (replace_len - search_len); result = (char*)malloc(result_len + 1); // 开始替换 char* p = result; s = str; while ((s = strstr(s, search)) != NULL) { int n = s - str; strncpy(p, str, n); p += n; strncpy(p, replace, replace_len); p += replace_len; str = s + search_len; } strcpy(p, str); return result; } int main(void) { const char* str = "Hello, world!"; const char* search = "world"; const char* replace = "everyone"; char* result = str_replace(str, search, replace); printf("替换前: %s\n", str); printf("替换后: %s\n", result); free(result); return 0; } ``` 上述代码实现了一个简单的`str_replace`函数。它首先统计了需要替换的次数,并根据替换的次数计算了替换后的字符串长度。然后,它分配了足够的内存空间来存储替换后的字符串,并进行了替换操作。最后,它返回了替换后的字符串。在`main`函数中,我们可以看到如何使用这个函数来替换一个字符串中的子字符串。 需要注意的是,本示例只是对`str_replace`函数的简单模拟实现,实际使用中还需要处理更多的边界情况和错误处理。 ### 回答2: C语言中没有内置的字符串替换函数,但我们可以通过模拟实现一个字符串替换函数。 首先,我们可以定义一个函数,该函数接受三个参数:源字符串、待替换的子字符串、替换后的子字符串函数的返回值是替换完成后的字符串。 接下来,我们可以使用循环来遍历源字符串。在每次循环中,比较源字符串中是否存在待替换的子字符串。如果存在,我们就将替换后的子字符串复制到新的字符串中。如果不存在,我们将源字符串中的当前字符复制到新的字符串中。 最后,返回新的字符串即可。 下面是一个简单的模拟实现示例: ```c #include <stdio.h> #include <string.h> char* stringReplace(char* source, const char* search, const char* replace) { char* result; int i, j, sourceLen, searchLen, replaceLen, count; sourceLen = strlen(source); searchLen = strlen(search); replaceLen = strlen(replace); count = 0; for (i = 0; i < sourceLen; i++) { if (strstr(&source[i], search) == &source[i]) { count++; i += searchLen - 1; } } result = (char*)malloc(sourceLen + count * (replaceLen - searchLen) + 1); i = 0; j = 0; while (source[i]) { if (strstr(&source[i], search) == &source[i]) { strcpy(&result[j], replace); j += replaceLen; i += searchLen; } else result[j++] = source[i++]; } result[j] = '\0'; return result; } int main() { char source[] = "Hello, World!"; const char search[] = "World"; const char replace[] = "C Language"; char* result = stringReplace(source, search, replace); printf("替换后的字符串: %s\n", result); free(result); return 0; } ``` 这是一个简单的模拟实现,实际上字符串替换还涉及到更多复杂的情况和细节,比如大小写敏感、替换次数限制等等。需要根据实际需求进行更进一步的完善。 ### 回答3: C语言字符串替换函数模拟实现的方法有很多,以下是一种可能的实现方式: ```c #include <stdio.h> #include <string.h> void str_replace(char *str, const char *find, const char *replace) { int find_len = strlen(find); int replace_len = strlen(replace); int str_len = strlen(str); char result[100]; int result_len = 0; int i = 0; while (i < str_len) { if (strncmp(&str[i], find, find_len) == 0) { // 找到需要替换的字符串 strncpy(&result[result_len], replace, replace_len); result_len += replace_len; // 跳过被替换的部分 i += find_len; } else { // 将原字符串的字符复制到结果字符串中 result[result_len] = str[i]; result_len++; i++; } } // 将新的结果字符串复制回原字符串中 strncpy(str, result, result_len); str[result_len] = '\0'; } int main() { char str[100] = "Hello, World!"; char find[10] = "World"; char replace[10] = "Alice"; printf("Before replace: %s\n", str); str_replace(str, find, replace); printf("After replace: %s\n", str); } ``` 这个函数的思路是首先计算出原字符串、需要查找的字符串以及替换的字符串的长度。然后以原字符串为基础,通过遍历每个字符的方式,查找需要替换的字符串,然后将替换的字符串复制到结果字符串中,同时跳过原字符串中已经被替换的部分。最后将结果字符串复制回原字符串中,完成字符串的替换。在主函数中,我们可以看到使用这个函数对原始字符串中的特定字符串进行了替换操作。运行程序后,可以输出替换后的字符串

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值