C语言字符串函数汇总

最新推荐文章于 2024-02-18 23:06:55 发布

打烂坏树

最新推荐文章于 2024-02-18 23:06:55 发布

阅读量475

点赞数

分类专栏： C语言文章标签：字符串 c++ c语言指针

本文链接：https://blog.csdn.net/qq_59116252/article/details/118802453

版权

C语言专栏收录该内容

1 篇文章 0 订阅

订阅专栏

介绍

在我们学习C语言的过程中，对字符串的处理是很频繁的，但是C语言本身是没有字符串类型的，所以就需要通过函数来方便我们对字符串的处理。

● 求字符串的长度

strlen

● 长度不受限制的字符串函数

strcpy

strcat

strcmp

● 长度受限制的字符串函数

strncpy

strncat

strncmp

了解这些函数之前我们应该知道字符串后面其实是有一个隐藏的\0得，这个\0要占一个字节的空间

就比如这个程序，我们再arr数组中放入“ABCD”，正常来讲四个字符类型数据，应该占四个字节。但是我们从右图可知，在“D”的后面还存在一个“\0”，也占了一个字节。这个“\0”也就是字符串结束的标志。

strlen函数

函数声明：size_t strlen (const char *string)

strlen函数的参数是个地址

函数原理：函数会从传入的地址开始往后走，直至找到字符串后面的“\0”才会停止，在寻找的同时会进行计数，找到“\0”后，就输出计数器上的数

注意：如果传入函数的是一个字符数组，结果将是一个随机值，因为数组里面的内容读取完之后，紧跟的后面那一位不一定就是“\0”，会继续向后进行寻找，直至找到“\0”才会停止寻找

strlen函数实现方式：

1计数器法：

#include<stdio.h>
#include<assert.h>
size_t my_strlen1(const char* str)//计数器法
{
	assert(str);
	int count = 0;//定义计数器
	while (*str)
	{
		str++;
		count++;
	}
	return count;//输出计数器上的数字
}
int main()
{
	char arr[] = "ABCD";
	int ret = my_strlen1(arr);
	printf("%d\n", ret);
	return 0;
}

2递归

#include<stdio.h>
#include<assert.h>
size_t my_strlen2(const char* str)
{
	assert(str);
	if (*str != '\0')
		return 1 + my_strlen2(str + 1);
	else
		return 0;
}
int main()
{
	char arr[] = "ABCD";
	int ret = my_strlen2(arr);
	printf("%d\n", ret);
	return 0;
}

3指针减指针法

#include<stdio.h>
#include<assert.h>
size_t my_strlen3(const char* str)
{	
	assert(str);
	const char* end = str;//将初始地址赋给指针end，用end来运算，确保str不变
	while (*end)
	{
		end++;
	}
	return end - str;//用末地址减去初始地址
}
int main()
{
	char arr[] = "ABCD";
	int ret = my_strlen3(arr);
	printf("%d\n", ret);
	return 0;
}

（注①：size_t==unsigned int）

（注②：字符串进行传参时，实际上传的是首字母的地址）

strcpy函数

函数声明：char* strcpy(char* destination, const char* source)

strcpy函数会将source的内容拷贝给destination（“\0”也会被拷贝，只不过遇到“\0”就会停止拷贝）

比如：char arr1[]="DISTINATION";

char arr2[]="SOURCE";

strcpy( arr1,arr2 );

相当于"\0"提前了，此时对arr1进行打印或者求字符串长度时，遇到\0都会停止。

倘若换一下，将arr1放入arr2，arr1的字节是12，而arr2是7个字节，arr2没有能力放入12个字节，此时程序就会出错（越界访问），因此我们应该要保证有足够的空间来存放源字符串。目标字符串不能为常量字符串，常量字符串相当于是个常量，不可修改。

图一：使用strcpy之前图二：使用strcpy之后

注意：1，源字符串必须以‘\0’结束
2，会将源字符串中的‘\0’拷贝到目标空间
3，目标空间必须足够大，以确保能存放源字符串

strcpy函数实现方式

char* my_strcpy(char* destination,const char* source)//返回类型为地址
{
	assert(destination);
	assert(source);
	char* address = destination;//储存destination的地址
	while (*destination++ = *source++)
	{
		;
	}
	return address;//返回地址，首尾呼应
}

strcat函数

函数声明：char* strcat(char* dest, const char* src)

把src所指向的字符串（包括“\0”）复制到dest所指向的字符串后面（删除*dest原来末尾的“\0”）。要保证*dest足够长，以容纳被复制进来的*src。*src中原有的字符不变。返回指向dest的指针

那么，strcat可以应用于同一个字符串？

答案是不可以，因为会把源字符串的\0替换掉，会死循环

应该注意：1，dest必须有足够的空间来容纳src的字符串。

2，调用函数之后，*dest字符串末尾的“\0”是*src末尾的“\0”

strcat函数的实现

char* my_strcat(char* dest, char* src)
{
	assert(dest);
	assert(src);
	char* p = dest;
	while (*dest)//找到目的字符串的\0
	{
		dest++;
	}
	while (*dest++ = *src++)//从\0开始往后录入src(\0)会被替换
	{
		;
	}
	return p;
}

strcmp函数

函数声明：int strcmp(const char* str1, const char* str2)

当str1<str2时，返回为负数；

当str1=str2时，返回值= 0；

当str1>str2时，返回正数。

即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止。

举例：strcmp(str1,str2)

d的ASCII码值是100，c的ASCII码值是99，根据函数的规则，返回的应该是负数。不同的编译器，返回的结果是不一样的，在vs环境下，返回值是1,0，-1。

strcmp函数的实现

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1&&str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')     //等于
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;        //大于
	else
		return -1;      //小于 

}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abccdef";
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
	return 0;
}

strncpy函数

函数声明：char* strncpy(char* destination, const char* source, size_t num)

表示把source所指向的字符串中以source地址开始的前num个字节复制到destination所指的数组中，并返回被复制后的destination。

char dest[10] = "hello";

char stc[] = "bit";

strncpy(dest, src, 2);

如果指定复制的字节数num大于stc中的字节数会怎么样呢？

如果我们把num换成5

对dest字符串进行延长（效果更明显）

char dest[10] = "helloabc";

char stc[] = "bit";

strncpy(dest, src, 5);

可见，这种情况下，strncpy相当于strcpy

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

strncpy函数的实现

char* my_strncpy(char* dest, const char* src, int step)
{
	assert(dest);
	assert(src);
	char* p = dest;   //保存源地址
	while (step)
	{
		if (*src != '\0')   //判断字符串src内容是否复制完
			*dest++ = *src++;
		else
			*dest++ = '\0';   //进行补\0，直至补到step
		step--;
	}
	return p;   //输入源地址
}

strncat函数

函数生命：char* strncat(char* destination, const char* source, size_t num)

strncat()将会从字符串src的开头拷贝n 个字符到dest字符串尾部，dest要有足够的空间来容纳要拷贝的字符串。如果n大于字符串src的长度，那么仅将src指向的字符串内容追加到dest的尾部。这一点不同于strncpy。

char dest[10] = "hello";

char src[] = "world";

strncat(dest, src, 3);

在hello后面，复制w o r这三个字符之后就进行补\0

char dest [20]="hello\0ppppppppp";

char src[]="bit";

strncat(dest, src, 8);

由于字符串函数都是找\0，我们在dest字符串加一个\0来模拟字符串后面的\0。不难发现，在源字符串被拷贝完之后，不会在目标字符串后面补\0补到8个字节。

该函数在使用时，也要确保目标字符串的空间要能够容纳要追加的字节数

strncat函数实现

char* my_strncat(char* dest, char* src, int step)
{
	assert(dest && src);    //断言：保证指针有效性
	char* p = dest;        //保存目标字符串地址
	while (*dest)
	{
		dest++;
	}
	while (step && (*dest++ = *src++))
	{
		step--;
	}
	*dest = '\0';        //内容复制完之后，在dest末尾补上\0
	return p;        //返回目标字符串地址
}

strncmp函数

函数声明：int strncmp ( const char * str1, const char * str2, size_t n )

功能是把 str1 和 str2 进行比较，最多比较前 n 个字节，若str1与str2的前n个字符相同，则返回0；若s1大于s2，则返回大于0的值；若s1 小于s2，则返回小于0的值。strncmp和strcmp功能基本相似，这里不再赘述

strncmp函数的实现

int my_strncmp(const char* dest, const char* src, int step)
{
	assert(dest && src);        //断言，保证指针有效性
	while (step)
	{
		if (*dest > *src)          //大于
			return 1;
		else if (*dest < *src)        //小于
			return -1;
		else
		{
			dest++;        //dest指针后移，比较下一位
			src++;        //src指针后移，比较下一位
			step--;        //步数减1
		}
	}
	return 0;        //相等
}

结束咯！

有需要再更新哈~.~