羊村懒王

这个屌丝很懒，什么也没留下！

热门标签

常用的字符串函数详解

作者：羊村懒王 | 2024-02-09 10:48:43

踩

字符串函数

strcmp()函数（字符串比较大小函数）

strlen()函数（求字符串长度函数）

strlen()函数简介

1.字符串以'\0'为结束标志，从给定的地址向后访问字符，strlen()函数返回的是字符串中'\0'前面出现字符的个数；


# include <string.h>
int main()
{
	char arr[] = "abcdef";
	int len = strlen(arr);
    printf("%d\n", len);
	return 0;
}

运行结果：

字符数组arr存放的元素 'a', 'b', 'c', 'd', 'e', 'f', '\0',所以结果为6.

2. 参数指向的字符必须以'\0'结束，因为如果不以'\0'作为结束标志，则strlen()函数所求的长度为随机值；


# include <string.h>
int main()
{
	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	int len = strlen(arr);
    printf("%d\n", len);
	return 0;
}

运行结果：

这个结果是随机值，会从给定位置arr向后一直查找'\0',直到查找到'\0'为止；

3.strlen()函数的返回值为size_t，为无符号整型；


int main()
{
	const char* p1 = "abcdef";
	//strlen(p1)=6;
	const char* p2 = "xxx";
	//strlen(p2)=3
 
	//由于strlen()函数的返回值为unsigned int
	// unsigned int A=3 unsigned int B=6
	//A-B进行的是A的补码+(-B)的补码，最后以无符号整型输出，所以p2>p1;
 
	if (strlen(p2) - strlen(p1) > 0)
	{
		printf("p2>p1\n");
	}
	else
		printf("p1>p2\n");
	return 0;
}

运行结果：

strlen()函数的模拟实现

assert() 头文件 # include<assert.h>
1.assert是宏，不是函数;
void assert(int expression)
2.如果expression结果为假即为0,断言失败，assert()会向标准输出装备输出一条错误消息，并调用abort()函数终止程序运行
3.如果expression表达式为真，断言成功，assert()不进行任何操作
assert()使用的注意事项:
每次断言只能检验一个条件，因为同时检查多个条件时，如果断言失败，无法直观判断是哪个条件失败;

计数器方式实现strlen()函数


# include <assert.h>
int my_strlen(const char* str)
{
	assert(str != NULL);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

递归的方式实现strlen()函数


int my_strlen(const char* str)
{
	assert(str != NULL);
	if (*str == '\0')
	{
		return 0;
	}
	else
		return 1 + my_strlen(str + 1);
}

指针-指针的方式实现strlen()函数

指针-指针的前提两个指针指向同一块内存空间
数组是在内存空间连续存放的，并且随着下标的增大地址从低到高变化;
因为指针-指针的绝对值是中间元素的个数，只需指向'\0'处的指针-指向数组首元素的指针便可得到;


int my_strlen(const char* str)
{
	assert(str != NULL);
	char* p = str;//p记录起始位置的地址
	while (*str != '\0')
	{
		str++;
	}
	return str - p;
}

strcpy()函数（字符串拷贝函数）

函数简介

1. strcpy()函数会将字符指针source所指向的字符串（包括终止字符'\0'）复制到字符指针

destination所指向的字符串;


int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

运算结果：

2. 原字符串必须以'\0'结束，如果不以'\0'结束，会导致程序崩溃;


int main()
{
	char arr1[] = "abcdef";
	char arr2[] = { 'a', 'b', 'c' };
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

运行结果：

3. 会将源字符串的 '\0'拷贝到目标空间；


int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

4.目标空间必须足够大，确保能存放源字符串；如果目标空间不够大，导致程序崩溃;


int main()
{
	char arr1[] = "xx";
	char arr2[] = "abcdef";
	strcpy(arr1, arr2);
	return 0;
}

运行结果:

5. 目标空间必须可变；


int main()
{
	//常量字符串不允许被修改，目标空间不可变，程序崩溃
	char*p = "abcdef";
	char arr[] = "abc";
	strcpy(p, arr);
	printf("%s\n", p);
	return 0;
}

运行结果：

6.strcpy()函数的返回值为目标空间的起始地址；strcpy()函数的返回类型设置为了实现链式访问；

strcpy()函数的模拟实现

strcpy()函数实现方式1


char* my_strcpy(char*dest,const char* src)
{
	assert(dest != NULL);
	assert(src != NULL);
	char* ret = dest;//记录目标空间的起始位置
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	//'\0'的拷贝
	*dest = *src;
	return ret;
}

strcpy()函数实现方式2


char* my_strcpy(char*dest, const char* src)
{
	assert(dest != NULL);
	assert(src != NULL);
	char* ret = dest;//记录目标空间的起始位置
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

strcat()函数（字符串追加函数）

函数简介

1. strcat()函数会将字符指针source所指向的字符串追加到字符指针destination所指向的字符串后面，并用 '\0' 终止字符串; 字符指针source所指向的字符串的初始字符覆盖字符指针destination所指向的字符串的'\0';


int main()
{
	char arr1[20] = "hello";
	char arr2[] = " world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

运行结果：

2. 源字符串必须以'\0'结束；

3.会将源字符串'\0'拷贝到目标空间；


int main()
{
	char arr1[20] = "hello\0xxxxxxxx";
	char arr2[] = " world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

4. 目标空间必须足够大，目标空间必须可变；

5. 原则上不允许字符串自己给自己追加，因为会覆盖掉'\0',从而进入死循环；


int main()
{
	char arr[20] = "world";
	strcat(arr, arr);
	printf("%s\n", arr);
	return 0;
}

运行结果：

strcat()函数的模拟实现

实现思路：

1. 首先找到目标空间字符串中的 '\0'；

2. 然后把源字符串拷贝到目标空间；


char* my_strcat(char* dest, const char*src)
{
	assert(dest != NULL);
	assert(src != NULL);
 
	//记录目标空间的起始地址
	char* ret = dest;
	//先找到目标空间中的 '\0'
	while (*dest != '\0')
	{
		dest++;
	}
	//字符串拷贝
	while (*dest++= *src++)
	{
		;
	}
	return ret;
}

strcmp()函数（字符串比较大小函数）

函数简介

1. strcmp()函数根据ASCII编码开始比较俩个字符串中的第一对字符，如果彼此相等, 继续   比较下一对字符所对应的ASCII码值，直到字符不相同或者达到终止字符'\0';

2. 函数返回值类型为 int

3. 函数返回值为0，表示俩个字符串相等；

    函数返回值为大于0的数字，表示第一个字符串大于第二个字符串；

    函数返回值为小于0的数字，表示第一个字符串小于第二个字符串；


int main()
{
	char* arr1 = "abcdef";
	char* arr2 = "abc";
	int ret = strcmp(arr1, arr2);
	if (ret > 0)
	{
		printf(">   ");
		printf("ret=%d\n", ret);
	}
	else if (ret == 0)
	{
		printf("=");
		printf("ret=%d\n", ret);
	}
	else
	{
		printf("<");
		printf("ret=%d\n", ret);
	}
	return 0;
}

运行结果

strcmp()函数的模拟实现


int my_strcmp(const char*s1, const char* s2)
{
	assert(s1 != NULL);
	assert(s2 != NULL);
 
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	if (*s1 > *s2)
		return 1;
	else
		return -1;
}

strstr()函数（字符串查找函数）

函数简介

strstr()函数是在字符指针str1指向的字符串中查找是否含有字符指针str2所指向的字符串；

如果存在，返回str2所指向的字符串在str1指向的字符串中第一次出现的地址；

否则返回NULL；


int main()
{
	char arr1[] = "abcdefcde";
	char arr2[] = "cde";
	char*ret=strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到子串\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

运行结果：

strstr()函数的模拟实现

情况1：

如果str1指向的字符和str2指向的字符不相等，则str1指向下一个字符，str2指针指向不变，循环往复，当str1指向'\0'时，得出str1所指向的字符串不含str2所指向的字符串，此时返回NULL; 如图

情况2：

当str1向后读取的过程中，发现两个指针指向的字符开始相等，str1继续向后读取字符，str2也向后读取字符，若str1所指向的字符和str2所指向的字符一直相等，直到str2指向 '\0', 此时可知str1所指向的字符串包含str2所指向的字符串；返回str2所指向的字符串在str1指向的字符串中第一次出现的地址；

情况3：

当str1向后读取的过程中，发现俩个指针指向的字符开始相等，str1继续向后读取字符，str2也向后读取字符，若str1所指向的字符和str2所指向的字符不全相等，此时str2需要返回到str2所指向字符串的首字符的地址，str1需要返回到第一次和str2所指向字符相等的后一个位置；


char* my_strstr(char* str1, char* str2)
{
	assert(str1 != NULL);
	assert(str2 != NULL);
 
	//创建s1,s2向后查找字符，保留str1,str2是为了方便返回;
	char* s1 = str1;
	char* s2 = str2;
 
	//需要一个指针记录str1中的字符串是从哪个位置开始匹配;
	char* cur = str1;
 
	while (*cur != 0)
	{
		s1 = cur;
		//s2回到起始位置;
		s2 = str2;
		while ((*s1!='\0')&&(*s2!='\0')&&(*s1==*s2))
		{
			s1++;
			s2++;
		}
		//子串中所有字符查找结束
		if (*s2 == '\0')
		{
			return cur;
		}
		//发现*s1!=*s2,说明当前位置不可能匹配成功
		//需要从下一个字符开始;
		cur++;
		//从cur++的位置跳转到s1=cur;的位置
		//因为当前位置不可能匹配成功,s1也应该指向下一个位置;
	}
	return NULL;
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/71534