可能是csdn上最好的字符串函数介绍

Posted 2021-10-04 m0_56186053

看之前可以赞一下吗???

字符串函数的介绍

在 C 语言中，字符串实际上是使用 null 字符 \\0 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

下面的声明和初始化创建了一个 RUNOOB 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 RUNOOB 的字符数多一个。
例如你可以

char [str]="string";

在字符串的结束系统会自动加上\\0
这里有许多C语言中常用的字符串函数，下面我们给予简单介绍

strlen

1.strlen的介绍

strlen相当于一个计数器，它从字符串开始到字符串结束标志\\0，来计算字符的个数

size_t strlen ( const char * str );

在C语言中字符串名字可以认为首元素的地址，字符的个数可以认为是正数，所以是无符号整型
2.strlen的模拟实现
首先进行断言，让传入的首地址不为空，定义计数器ret
每次字符不为空，让ret+1。
`

``c
size_t My_strlen(const char* str)
{
	assert(str);
	int ret = 0;
	while (*str)
	{
		*str++;
		ret++;
	}
	return ret;
}
int main()
{
	char str[] = "wwwzzzyyy";
	int ret=strlen(str);
	int My_ret = My_strlen(str);
	printf("%d %d", ret,My_ret);
}
```![在这里插入图片描述](https://img-blog.csdnimg.cn/3eb6c470aa0b43819c0d02ef65af0419.png)

结果完全正确

strcpy

1.strcpy的介绍
strcpy的作用是将源指向的C字符串复制到目标指向的数组中，包括终止的空字符（并在该点停止）。
为了避免溢出，目标指向的数组的大小应该足够长，以包含与源相同的C字符串（包括终止的空字符），并且不应该在内存中与源重叠
2.strcpy的模拟实现
char * strcpy ( char * destination, const char * source )
这是函数的基本返回类型和参数的类型，其中源字符串不可以被改变，所以我们加上const修饰
函数基本实现细节如下
里边的*destination++ = *source++意味着先将源字符赋值给目标字符串。
但是要注意要把目标字符串的地址保存下来

char My_strcpy(char* destination, const char* source)
{
	assert(destination && source);
	char* ret = destination;//先用一个字符串指针记录首地址；
	while (*destination++ = *source++)
	{
		;
	}
	return ret;//返回目标字符串的第一个地址；
}

strcmp

1.strcmp函数的简介
trcmp函数是string compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数。基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。
两个字符串自左向右逐个字符相比（按 ASCII 值大小相比较），直到出现不同的字符或遇 \\0 为止。如：

1.“A”<“B”
2.“A”<“AB”
3.“Apple”<“Banana”
4.“A”<“a”
5.“compare”<“computer”
2.strcmp函数的形式

extern int strcmp(const char *s1,const char *s2);

3.strcmp函数的模拟实现

```c
int My_strcmp(const char* dest, const char* source)
{
	assert(dest && source);
	while (*dest == *source)
	{
		if (*dest == '\\0')
			return 0;
		*dest++;
		*source++;
	}
	return *dest - *source;
}

这里先断言两个字符串，当两个字符相等时才进入循环，当两个字符相等，且都为0是表示两个字符串相等
否则返回两个字符的差

strcat

1.strcat函数的简介
C 库函数 char *strcat(char *dest, const char *src) 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。
2.strcat函数的声明

char *strcat(char *dest, const char *src) 

注意 dest是目标字符串的地址，src是源字符串的地址
3.strcat的用法

#include <stdio.h>
#include <string.h>
 
int main ()
{
   char src[50], dest[50];
 
   strcpy(src,  "This is source");
   strcpy(dest, "This is destination");
 
   strcat(dest, src);
 
   printf("最终的目标字符串： |%s|", dest);
   
   return(0);
}

其中要注意的是在追加字符串的时候不可以越界
4.strcat的模拟实现

char My_strcat(char* dest, const* src)
{
	char* ret = dest;
	//先用ret记录起始字符地址
	assert(dest && src);
	while (dest++)
	{
		;
	}
	//找到dest=0；
	
	while (*dest++=*src++)
	{
		;
	}
	return dest;
}

先找到0的位置，再进行复制

char str[100] = "wwwzzzyyyzzz";
	char strp[] = "HELLO WORLD!";

注意我们把目标字符串的容量变得很大
字符串追加函数要注意5点:

1.目标字符串中必须有’\\0’

2.源字符串中必须有’\\0’

3.目标字符串必须可修改

4.目标空间必须足够大

5.自己不能给自己追加

strstr

1.strstr函数的介绍
strstr是C语言中的函数，作用是返回字符串中首次出现子串的地址
2.strstr函数的声明
char * strstr(str1,str2)
str1: 被查找目标　string expression to search.
str2: 要查找对象　The string expression to find.
返回值：若str2是str1的子串，则返回str2在str1的首次出现的地址；如果str2不是str1的子串，则返回NULL。
3.strstr函数的实现

char My_strstr(char* str1, char* str2)
{
	char* s1;
	char* s2;
	char* cp;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 != '\\0' && *s2 != '\\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\\0')
		{
			return cp;
		}
		cp++;

	}
	return NULL;
}

例如str1–abbccfg str2–bbc
这里我们先从第一个a开始，然后与str2进行相比，但是比较不出，所以我们将cp++；继续找；但是要注意两个字符串都不能为‘\\0’才行

memcpy

1.函数简介

memcpy指的是C和C++使用的内存拷贝函数，函数原型为void *memcpy(void *destin, void *source, unsigned n)；函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，即从源source中拷贝n个字节到目标destin中
2.函数声明

void *memcpy(void *destin, void *source, unsigned n);

```参数
destin-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
source-- 指向要复制的数据源，类型强制转换为 void* 指针。
n-- 要被复制的字节数。
返回值
该函数返回一个指向目标存储区destin的指针。
功能
从源source所指的内存地址的起始位置开始拷贝n个字节到目标destin所指的内存地址的起始位置中。 [2] 
所需头文件
C语言：#include<string.h>
C++：#include<cstring>

3.函数用法

// 将字符串复制到数组 dest 中
#include <stdio.h>
#include <string.h>
 
int main ()
{
   const char src[50] = "http://www.runoob.com";
   char dest[50];
 
   memcpy(dest, src, strlen(src)+1);
   printf("dest = %s\\n", dest);
   
   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

dest = http://www.runoob.com
3.函数实现

void* My_memcpy(void* dest, const void* src, size_t count)
{
	void* ret = dest;//用ret来保存初始地址
	assert(dest && src);
	while (count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return;
}

注意void* 类型无法做加减运算，我们要先强制类型转换.

memmove

1.函数简介
memmove用于拷贝字节，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，但复制后源内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同
2.函数声明

原型：void memmove( void dest, const void* src, size_t count );
头文件：<string.h>
功能：由src所指内存区域复制count个字节到dest所指内存区域。
3.函数用法

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

int main ()
{
   const char dest[] = "oldstring";
   const char src[]  = "newstring";

   printf("Before memmove dest = %s, src = %s\\n", dest, src);
   memmove(dest, src, 9);
   printf("After memmove dest = %s, src = %s\\n", dest, src);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果：

Before memmove dest = oldstring, src = newstring
After memmove dest = newstring, src = newstring

4.函数实现

void Memmove(void* b, void* a, int bitlen)
{
char* aa = (char*)a;
char* bb = (char*)b;
if (bb >= aa && bb <= aa + bitlen)
{
aa = aa + bitlen - 1;
bb = bb + bitlen - 1;
for (int i = 0;i < bitlen;i++)
{
*bb = *aa;
aa–;
bb–;
}
}
else
{
for (int i = 0;i < bitlen;i++)
{
*bb = *aa;
bb++;
aa++;
}
}
}
int main()
{
int a[5] = { 1,2,3,4 };
Memmove(a + 1, a, 16);
for (int i = 1;i <= 4;i++)
{
printf("%d “, a[i]);
}
printf(”\\n");
system(“pause”);
return 0;
}

以上就是字符串函数介绍了，希望各位三连加关注呀