【C语言】字符函数和字符串函数

我就是我 2023-10-15 15:56 71阅读 0赞

**目录**

一、函数介绍及其模拟实现

1.strlen

2.strcpy

3.strcat

4.strcmp

5.strncpy

6.strncat

7.strncmp

8.strstr

9.strtok

10.strerror

11.其他字符串函数

二、内存函数

1.memcpy

2.memove

3.memcmp

--------------------

**前言**

> **在平时我们处理一些数据时，尤其是字符串，我们经常会用到库函数中的strlen、strcmp等，C语言本身是没有字符串类型的，字符串通常放在常量字符串和字符数组中。**

## 一、函数介绍及其模拟实现 ##

### 1.strlen ###

**(1)函数头部**

> **size\_t** **strlen(** **const** **char** **\****string* **);**

**(2)注意事项**

>  *  字符串以 '\\0'作为结束标志，strlen函数返回的是在字符串'\\0'前面出现的字符的个数（不含\\0）
>  *  参数指向的字符串必须要以\\0结束
>  *  函数的返回值是类型是 size\_t 这是无符号整型（易错）

![8eb49f38fc7f47ff870e33f23c6cca08.png][]\+

**(3)strlen的使用**

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char* str = "abcef";
    	int len = strlen(str);//获取字符串的长度
    	printf("%d",len);
    	return 0;
    }

**(4)strlen的模拟实现**

//普通实现
    #include<stdio.h>
    int my_strlen(char *str) 
    {
    	int count = 0;
    	while (*str++) 
    		count++;
    	return count;
    }
    int main()
    {
    	char* str = "abcdef";
    	int len = my_strlen(str);
    	printf("%d",len);
    	return 0;
    }

//链式访问实现

#include<stdio.h>
    int my_strlen(char *str) 
    {
    	int count = 0;
    	while (*str++) 
    		count++;
    	return count;
    }
    int main()
    {
    	char* str = "abcdef";
    	printf("%d",my_strlen(str));//链式访问
    	return 0;
    }

//函数递归实现

#include<stdio.h>
    int my_strlen(char* str)
    {
    	if (*str == '\0')
    		return 0;
    	else
    		return (1 + my_strlen(str + 1));
    }
    int main() 
    {
    	char* str = "abcdef";
    	int len = my_strlen(str);
    	printf("%d",len);
    	return 0;
    }

//指针-指针实现

//指针- 指针
    #include<stdio.h>
    int my_strlen(char*str)
    {
    	char* end = str;
    	while (*end)
    		end++;
    	return end - str;
    }
    int main() 
    {
    	char* str = "abcdef";
    	int len = my_strlen(str);
    	printf("%d",len);	
    	return 0;
    }

### 2.strcpy ###

![fe9a3d633ccb452a9f8fd0ddddf43ff2.png][]

**(1)函数头部**

> **char** **\*strcpy(** **char** **\****strDestination***,** **const** **char** **\****strSource* **);**

**(2)注意事项**

>  *  源字符串以'\\0'结束。
>  *  会将源字符串的’\\0‘拷贝的目标空间
>  *  目标空间必须足够大，以保证能放下源字符串
>  *  目标空间必须可变

**(3)strcpy的使用**

#include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char str1[20] = {0};
    	char* str2 = "abcdef";
    	strcpy(str1,str2);
    	printf("%s",str1);
    	return 0;
    }

*  **(4)strcpy的模拟**

#include<stdio.h>
    #include<assert.h>
    char* my_strcpy(char* str1, const char* str2)
    {
    	assert(str1&&str2);//断言避免指针为空
    	char* ret = str1;
    	while (*str1++ = *str2++)
    		;
    	return ret;
    }
    int main()
    {
    	char str1[20] = { 0 };
    	char* str2 = "abcdef";
    	printf("%s", my_strcpy(str1, str2));
    	return 0;
    }

### 3.strcat ###

![645b7bf2d0d045e5ab7b0bbe3d580333.png][]

**(1)函数头部**

> **char** **\*strcat(** **char** **\****strDestination***,** **const** **char** **\****strSource* **);**

**(2)注意事项**

>  *  源字符必须以‘\\0’结束
>  *  目标空间必须有足够大能容纳下源字符串
>  *  目标空间必须可以修改
>  *  strcat不能自己给自己追加

**(3)strcat的使用**

//strcat的使用
    #include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char str1[20] = "abcdef";
    	char* str2 = "112233";
    	strcat(str1,str2);
    	printf("%s",str1);
    	return 0;
    }

![ed6465e3b7fa42bda3a85c0fbc3a3261.png][]  
**（4）strcat的模拟实现**

#include<stdio.h>
    #include<assert.h>
    char* my_strcat(char*dest,const char*src) 
    {
    	char* ret = dest;
    	while (*dest)
    		dest++;
    	while (*dest++ = *src++)
    		;
    	return ret;
    }
    int main()
    {
    	char str1[20] = "abcdef";
    	char* str2 = "112233";
    	my_strcat(str1, str2);
    	printf("%s", str1);
    	return 0;
    }

![0e68c218c5df4702a02c0e183e7e74af.png][]

### 4.strcmp ###

![c20ddfb95bde464f8d630de7df02442d.png][]

**(1)函数头部**

> **int** **strcmp(** **const** **char** **\****string1*, **const** **char** **\****string2* **);**

**(2)注意事项**

>  *  根据标准规定
>  *  第一个字符串 大于 第二个字符串，返回大于0的数字
>  *  第一个字符串 等于 第二个字符串 ，返回0
>  *  第一个字符串 小于 第二个字符串，返回小于0的数字

![c7378fd60101476bb0d3acb8fb30b484.png][]

**(3)strcmp的使用**

#include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char* str1 = "abcdef";
    	char* str2 = "aaaaaa";
    	int ret = strcmp(str1,str2);//可以知道 str1>str2
    	printf("%d",ret);//编译器返回一个大于0的数字
    	return 0;
    }

![2e00594b1f5e47b28dccc941908495e9.png][]

**(4)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++;
    	}
    	return (*str1 - *str2);
    }
    int main()
    {
    	char* str1 = "abcdef";
    	char* str2 = "aaaaaa";
    	int ret = my_strcmp(str1, str2);
    	printf("%d", ret);
    	return 0;
    }

我们发现上述字符串函数 的字符串长度不受到限制

接下来介绍几个长度受到限制的字符串函数

--------------------

### **5.strncpy** ###

**(1)函数头部**

> **char** **\*strncpy(** **char** **\****strDest***,** **const** **char** **\****strSource***,** **size\_t** *count* **);**

**(2)注意事项**

>  *  拷贝count个字符从源字符串到目标空间
>  *  如果源字符小于count,则考完源字符串后，在目标的后面追加0，直到count个

**(3)strncpy的使用**

#include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char str1[20] = "aa";
    	char str2[] = "bbb";
    	strncpy(str1,str2,5);
    	printf("%s",str1);
    	return 0;
    }

接下来我们一下调试的内容

![52868af1303148a4b8775506bc64c544.png][]

### **6.strncat** ###

**(1)函数头部**

> **char** **\*strncat(** **char** **\****strDest***,** **const** **char** **\****strSource***,** **size\_t** *count* **);**

**(2)注意事项**

>  *  当源字符串小于count,并不会一直追加，而是追加完字符串的时候再加上‘\\0’,目标是完成源字符串内容
>  *  当等于count，会再追加一个上‘\\0’
>  *  没有额外追加

**(3)strncat的使用**

//strncat的使用
    #include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char str1[20] = "aaa";
    	char* str2 = "bbc";
    	strncat(str1,str2,3);
    	printf("%s",str1);
    	return 0;
    }

![607e4a37c87a481f851dd7380a46be51.png][]

### 7.strncmp ###

**(1)函数头部**

> **int** **strncmp(** **const** **char** **\****string1***,** **const** **char** **\****string2***,** **size\_t** *count* **);**

**(2)注意事项**

>  *  比较到出现另一个字符不一样，或者一个字符串结束，或者count个字符全部比较完

![172412fad0f949b7ad7995207d724003.png][]

< 0 不匹配的第一个字符在 str1 中的值低于 str2 中的值

0 两个字符串的内容相等

>0 第一个不匹配的字符在str1中的值比在str2中的值大

**(3) strncmp的使用**

//strncmp的使用
    #include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char* str1 = "aaab";
    	char* str2 = "abba";
    	int len = strncmp(str1,str2,2);//比较前两个字符
    	printf("%d",len);
    	return 0;
    }

![413747635d264504be0df077b1c6067d.png][]

--------------------

### 8.strstr ###

![5a852c773cfe4eedb933d67fea643036.png][]

**(1)函数头部**

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

**(2)注意事项**

> 在str1中找 str2在（str1）第一次出现的位置

**(3)strstr的使用**

#include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char* str1 = "abcxaxad";
    	char* str2 = "xax";
    	char* ret = strstr(str1,str2);
    	printf("%s",ret);
    	return 0;
    }

![60cc8a65314b4ccbba2ced4d56a6945e.png][]

**(4)strstr模拟实现**

//strstr的模拟实现
    #include<stdio.h>
    #include<assert.h>
    char* my_strstr(const char* str1,const char* str2) 
    {
    	assert(str1&&str2);
    	char* cp = str1;
    	char* p1 = str1;
    	char* p2 = str2;
    	while (cp) 
    	{
    		p1 = cp;//从cp指向的字符开始
    		p2 = str2;//从子串的首字符开始
    		while (*p1 == *p2 && *p1 && *p2) 
    		{
    			p1++;
    			p2++;
    		}
    		if (*p2 == '\0')
    			return cp;
    		cp++;
    	}
    	return NULL;
    
    }
    int main() 
    {
    	char* str1 = "abcxaxad";
    	char* str2 = "xax";
    	char* ret = my_strstr(str1,str2);
    	printf("%s",ret);
    	return 0;
    }

![f68310b8b33d44ed830b68557b7af72f.png][]

**图解：**

**起始情况**

![a8189aea812c4e3fb5dc6321254830c5.png][]

**找到的时候**

![02f93906269545d58ab4a43a893eb7c9.png][]

### 9.strtok ###

**(1)函数头部**

> **char** **\*strtok(** **char** **\****str***,** **const** **char** **\****sep* **);**

**(2)注意事项**

>  *  sep 参数是个字符串，定义了用作分隔符的字符集合
>  *  第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割标记。
>  *  strtok函数找到str中的下一个标记，并将其用 \\0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
>  *  strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
>  *  strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
>  *  如果字符串中不存在更多的标记，则返回 NULL 指针

**(3)strtok的使用 ( 把字符串根据 分隔符 分隔开来)**

#include<stdio.h>
    #include<string.h>
    int main() 
    {
    	char* p = "aabbcc@112233.abc";
    	const char* sep = "@.";
    	char arr[30];
    	char* str = NULL;
    	strcpy(arr,p);//临时拷贝字符串
    	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    		printf("%s\n",str);
    	return 0;
    }

![fe6e940f942a48e8914bcd3093be6507.png][]

### 10.strerror ###

返回错误码，所对应的错误信息（这里是程序运行时的错误）

在介绍其他知识：库函数在执行时,发生了错误，会将一个错误码存到errno这个变量中（全局变量）

**(1)函数头部**

> **char \* strerror( int errnum );**

**(2)strerror的使用**

#include<stdio.h>
    #include<string.h>
    #include<errno.h>
    int main() 
    {
    	int i = 0;
    	for (i = 0; i < 10;i++)
    	{
    		printf("%d is %s\n",i,strerror(i));//打印错误码 0到9的错误信息
    	}
    }

![0ec64911067e42b9be3b425069c266df.png][]

--------------------

### 11.其他字符串函数 ###

<table style="width:500px;">  字符分类函数  
 <tbody> 
  <tr> 
   <td style="width:148px;">iscntr</td> 
   <td style="width:350px;">任何控制字符</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isspace</td> 
   <td style="width:350px;"> <p>空白字符: 空格 ' '，换页 ‘\f，换行 '\n'，回车 '\r' ，制表符 ‘\t’，垂直制表符 ‘\v’</p> </td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isdigit</td> 
   <td style="width:350px;">十进制数字 0 - 9</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isxdigit</td> 
   <td style="width:350px;">十六进制数字 0 - 9 ，a - f</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">islower</td> 
   <td style="width:350px;">小写字母 a- z</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isupper</td> 
   <td style="width:350px;">大写字母 A - Z</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isalpha</td> 
   <td style="width:350px;">字母 a - z , A - Z</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isalnum</td> 
   <td style="width:350px;">字母或者数字&nbsp;a - z , A - Z，0 - 9</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">ispunct</td> 
   <td style="width:350px;">标点符号，任何不属于字母和数字的图形字符</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isgragh</td> 
   <td style="width:350px;">任何图形字符</td> 
  </tr> 
  <tr> 
   <td style="width:148px;">isprint</td> 
   <td style="width:350px;">可以打印任何字符</td> 
  </tr> 
 </tbody> 
</table>

##  ##

根据上述字符函数，【例如】islower(a) 如果圆括里面的是小写字母，该函数就返回真。

## 二、内存函数 ##

### 1.memcpy ###

**(1)函数头部**

> **void** **\*memcpy(** **void** **\****dest***,** **const** **void** **\****src***,** **size\_t** *count* **);**

**(2)注意事项**

>  *  函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
>  *  这个函数在遇到 '\\0' 的时候并不会停下来
>  *  用来处理不重叠的内存拷贝，如果source和destination有任何的重叠，复制的结果都是未定义的
>  *  size\_t count 是 字节的个数

**(3)memcp的使用**

#include<stdio.h>
    #include<string.h>
    int main() 
    {
    	int arr1[] = {1,2,3,4,5};
    	int arr2[20] = {0};
    	//将arr1中的内容拷贝到arr2中
    	memcpy(arr2,arr1,20);
    	int i = 0;
    	for (i = 0; i < 20;i++)
    	{
    		printf("%d ",arr2[i]);
    	}
    	return 0;
    }

**(4)memcpy的模拟使用**

//memcpy的模拟实现
    #include<stdio.h>
    #include<assert.h>
    void* my_memcpy(void* dest, const void *src ,size_t count) 
    {
    	assert(dest && src);
    	void* ret = dest;
    	while (count--)//count表示的是字节的个数
    	{
    		//因为char类型是占一个字节
    		*(char*)dest = *(char*)src;
    		dest = (char*)dest + 1;
    		src = (char*)src + 1;
    	}
    	return dest;
    }
    int main()
    {
    	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int arr2[20] = {0};
    	my_memcpy(arr2,arr1,40);
    	int i = 0;
    	for (i = 0; i < 20;i++)
    	{
    		printf("%d ",arr2[i]);
    	}
    	return 0;
    }

### **2.memove** ###

**(1)函数头部**

> **void** **\*memmove(** **void** **\****dest***,** **const** **void** **\****src***,** **size\_t** *count* **);**

**(2)注意事项**

>  *  和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的
>  *  如果源空间和目标空间出现重叠，就是可以使用memmove进行处理
>  *  用重叠的内存拷贝

**(3)memmove的使用**

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	//这里我们给str自己拷贝一个123
    	char str[] = "web online 123";
    	memmove(str, str + 11,3);//可以用于重叠内存拷贝
    	printf("%s",str);
    	return 0;
    }

![446bfc473de64456b26d585ea643a1a1.png][]

**(4)memmove的模拟实现**

//memmove的模拟实现
    #include<stdio.h>
    #include<assert.h>
    void* my_memmove(void* dest,const void* src,size_t num) 
    {
    	assert(dest&&src);
    	void* ret = dest;
    	//当地址src 小于 dest的时候
    	if (dest < src) 
    	{
    		//这里我们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 ret;
    }
    int main()
    {
    	int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    	my_memmove(arr1, arr1 + 2,12);//前->后
    	//my_memmove(arr1+5,arr1+2,12);//后->前
    	int i = 0;
    	for (i = 0; i < 10;i++)
    	{
    		printf("%d ",arr1[i]);
    	}
    	return 0;
    }

前->后

![d8eddaf20f8747018c90fa747c26103c.png][]

后->前

![79902db9c0b943fe841bf86910f87613.png][]

**情况1**

![d7684fc2377d4cb899d0c7ca8f1b49ee.png][]

![461248ae38d84d6fb8cffc53a9230de7.png][]

**情况2**

![4e8800f28a66450ba3c0fac04842b0ba.png][]

![b14ec5c8fef54e88a3834d7d13872eb7.png][]

### 3.memcmp ###

**(1)函数头部**

> **int** **memcmp(** **const** **void** **\****buf1***,** **const** **void** **\****buf2***,** **size\_t** *count* **);**

**(2)注意事项**

>  *  比较从buf1 和 buf2 指针开始的num个字节
>  *  The **memcmp** function compares the first *count* bytes of *buf1* and *buf2* and returns a value indicating their relationship.
>  *  注意该函数的return value
>  *  ![694dee3faa5243c789b394e0c07bde5e.png][]

**(3)memcmp的使用**

//memcmp的使用
    #include<stdio.h>
    #include<string.h>
    int main()
    {
    	char buf1[] = "aabbcc2210";
    	char buf2[] = "aabbcc2211";
    	int n = 0;
    	n = memcmp(buf1,buf2,sizeof(buf1));
    	if (n > 0)
    		printf("buf1大于buf2");
    	else if (n < 0)
    		printf("buf1小于buf2");
    	else
    		printf("buf1等于buf2");
    	return 0;
    }

![dba42b87ffb4444db839904fbf28ed56.png][]

[8eb49f38fc7f47ff870e33f23c6cca08.png]: https://img-blog.csdnimg.cn/8eb49f38fc7f47ff870e33f23c6cca08.png
[fe9a3d633ccb452a9f8fd0ddddf43ff2.png]: https://img-blog.csdnimg.cn/fe9a3d633ccb452a9f8fd0ddddf43ff2.png
[645b7bf2d0d045e5ab7b0bbe3d580333.png]: https://img-blog.csdnimg.cn/645b7bf2d0d045e5ab7b0bbe3d580333.png
[ed6465e3b7fa42bda3a85c0fbc3a3261.png]: https://img-blog.csdnimg.cn/ed6465e3b7fa42bda3a85c0fbc3a3261.png
[0e68c218c5df4702a02c0e183e7e74af.png]: https://img-blog.csdnimg.cn/0e68c218c5df4702a02c0e183e7e74af.png
[c20ddfb95bde464f8d630de7df02442d.png]: https://img-blog.csdnimg.cn/c20ddfb95bde464f8d630de7df02442d.png
[c7378fd60101476bb0d3acb8fb30b484.png]: https://img-blog.csdnimg.cn/c7378fd60101476bb0d3acb8fb30b484.png
[2e00594b1f5e47b28dccc941908495e9.png]: https://img-blog.csdnimg.cn/2e00594b1f5e47b28dccc941908495e9.png
[52868af1303148a4b8775506bc64c544.png]: https://img-blog.csdnimg.cn/52868af1303148a4b8775506bc64c544.png
[607e4a37c87a481f851dd7380a46be51.png]: https://img-blog.csdnimg.cn/607e4a37c87a481f851dd7380a46be51.png
[172412fad0f949b7ad7995207d724003.png]: https://img-blog.csdnimg.cn/172412fad0f949b7ad7995207d724003.png
[413747635d264504be0df077b1c6067d.png]: https://img-blog.csdnimg.cn/413747635d264504be0df077b1c6067d.png
[5a852c773cfe4eedb933d67fea643036.png]: https://img-blog.csdnimg.cn/5a852c773cfe4eedb933d67fea643036.png
[60cc8a65314b4ccbba2ced4d56a6945e.png]: https://img-blog.csdnimg.cn/60cc8a65314b4ccbba2ced4d56a6945e.png
[f68310b8b33d44ed830b68557b7af72f.png]: https://img-blog.csdnimg.cn/f68310b8b33d44ed830b68557b7af72f.png
[a8189aea812c4e3fb5dc6321254830c5.png]: https://img-blog.csdnimg.cn/a8189aea812c4e3fb5dc6321254830c5.png
[02f93906269545d58ab4a43a893eb7c9.png]: https://img-blog.csdnimg.cn/02f93906269545d58ab4a43a893eb7c9.png
[fe6e940f942a48e8914bcd3093be6507.png]: https://img-blog.csdnimg.cn/fe6e940f942a48e8914bcd3093be6507.png
[0ec64911067e42b9be3b425069c266df.png]: https://img-blog.csdnimg.cn/0ec64911067e42b9be3b425069c266df.png
[446bfc473de64456b26d585ea643a1a1.png]: https://img-blog.csdnimg.cn/446bfc473de64456b26d585ea643a1a1.png
[d8eddaf20f8747018c90fa747c26103c.png]: https://img-blog.csdnimg.cn/d8eddaf20f8747018c90fa747c26103c.png
[79902db9c0b943fe841bf86910f87613.png]: https://img-blog.csdnimg.cn/79902db9c0b943fe841bf86910f87613.png
[d7684fc2377d4cb899d0c7ca8f1b49ee.png]: https://img-blog.csdnimg.cn/d7684fc2377d4cb899d0c7ca8f1b49ee.png
[461248ae38d84d6fb8cffc53a9230de7.png]: https://img-blog.csdnimg.cn/461248ae38d84d6fb8cffc53a9230de7.png
[4e8800f28a66450ba3c0fac04842b0ba.png]: https://img-blog.csdnimg.cn/4e8800f28a66450ba3c0fac04842b0ba.png
[b14ec5c8fef54e88a3834d7d13872eb7.png]: https://img-blog.csdnimg.cn/b14ec5c8fef54e88a3834d7d13872eb7.png
[694dee3faa5243c789b394e0c07bde5e.png]: https://img-blog.csdnimg.cn/694dee3faa5243c789b394e0c07bde5e.png
[dba42b87ffb4444db839904fbf28ed56.png]: https://img-blog.csdnimg.cn/dba42b87ffb4444db839904fbf28ed56.png