字符函数和字符串函数------------ C语言

Love The Way You Lie 2023-09-30 02:28 139阅读 0赞

**本篇主要是介绍字符和字符串的****库函数****的使用方法**

**目录**

1.求字符串长度

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

（1）strcpy

(2) strcat

(3) strcmp

3. 长度受限制的字符串函数

(1) strncpy

(2) strncat

(3)strncmp

4. 字符串查找

(1) strstr

（2）strtok

5.内存操作函数

(1) memcpy

(2) memmove

(3)memcmp

(4) memset

还有一些字符分类函数

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

## 1.求字符串长度 ##

>  strlen() 计算字符串长度
> 
> 声明   **size\_t strlen(const char \*str)**
> 
> 头文件 \#include<string.h>
> 
> 计算字符串 **str** 的长度，直到空结束字符，但不包括 '\\0' 字符。

下面模拟实现库函数strlen

#define _CRT_SECURE_NO_WARNINGS 1
    #include<assert.h>
    #include<stdio.h>
    //strlen模拟实现
    
    
    size_t my_strlen(const char* str)
    {
    	int count = 0;
    	assert(str != NULL);
    	while (*str !='\0')
    	{
    		count++;
    		str++;
    	}
    	return count;
    }
    
    
    int main()
    {
    	char arr[] = "abcdef";
    	int len = my_strlen(arr);
    	printf("%d\n", len);
    	return 0;
    }

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

## 2.长度不受限制的字符串函数 ##

### （1）strcpy ###

> strcpy（）字符串拷贝
> 
> 声明  **char \*strcpy(char \*dest, const char \*src)**
> 
> 头文件 \#include<string.h>
> 
> 返回值 该函数返回一个指向最终的目标字符串 dest 的指针
> 
> 注意 如果目标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的情况。

下面模拟实现库函数strcpy

//strcpy模拟实现
    #include<stdio.h>
    #include<assert.h>
    char* my_strcpy( char* dest,const char* str)
    {
    	assert(dest != NULL);
    	assert(str != NULL);
    	//assert(dest&&str);
    	char* ret = dest;
    	while (*dest++ = *str++)
    	{
    		;
    	}
    	return ret;
    }
    int main()
    {
    	char arr1[20] = {0};
    	char* arr2 = "abcdef";
    	my_strcpy(arr1, arr2);
    	printf("%s\n", arr1);
    	return 0;
    }

### (2) strcat ###

> strcat() 字符串追加
> 
> 声明 **char \*strcat(char \*dest, const char \*src)**
> 
> 头文件 \#include<stdio.h>
> 
> 把 **src** 所指向的字符串追加到 **dest** 所指向的字符串的结尾。

下面模拟实现库函数strcat

//strcat模拟实现 连接
    #include<stdio.h>
    #include<assert.h>
    char* my_strcat(char* dest, char* str)
    {
    	assert(dest && str);
    	char* len = dest;//找到目标空间的'\0'
    	while (*dest)
    	{
    		dest++;
    	}
    	while (*dest++ = *str++)//拷贝
    	{
    		;
    	}
    	return len;
    }
    int main()
    {
    	char arr1[20] = "hello";
    	char arr2[] = " bit";
    	printf("%s\n",my_strcat(arr1, arr2));
    
    
    	return 0;
    }

### (3) strcmp ###

> strcmp() 字符串比较
> 
> 声明 **int strcmp(const char \*str1, const char \*str2)**
> 
> 头文件 \#include<stdio.h>
> 
> 把 **str1** 所指向的字符串和 **str2** 所指向的字符串进行比较。
> 
>  *  如果返回值小于 0，则表示 str1 小于 str2。
>  *  如果返回值大于 0，则表示 str1 大于 str2。
>  *  如果返回值等于 0，则表示 str1 等于 str2。

下面模拟实现库函数strcmp

//strcmp模拟实现 比较
    #include<stdio.h>
    #include<assert.h>
    int my_strcmp(const char* dest,const char* str)
    {
    	assert(dest && str);
    	while (*dest == *str)
    	{
    		//相等
    		if (*dest == '\0')
    		{
    			return 0;
    		}
    		dest++;
    		str++;
    	}
    	return *dest - *str;
    }
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "abq";
    	int len=my_strcmp(arr1, arr2);
    
    
    	if (len > 0)
    	{
    		printf(">\n");
    	}
    	else if (len == 0)
    	{
    		printf("==\n");
    	}
    	else
    	{
    		printf("<\n");
    	}
    	return 0;
    }

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

## 3. 长度受限制的字符串函数 ##

### (1) strncpy  ###

> strncpy() 拷贝字符串中有限个字符
> 
> 声明 **char \*strncpy(char \*dest, const char \*src, size\_t n)**
> 
> 头文件 \#include<string.h>
> 
> 把 **src** 所指向的字符串复制到 **dest**，最多复制 **n** 个字符。当 src 的长度小于 n 时，dest 的剩余部分将用空字节填充。

### (2) strncat ###

> strncat() 追加字符串中有限个字符
> 
> 声明 **char \*strncat(char \*dest, const char \*src, size\_t n)**
> 
> 头文件 \#include<string,h>
> 
> 把 **src** 所指向的字符串追加到 **dest** 所指向的字符串的结尾，直到 **n** 字符长度为止。

### (3)strncmp ###

> strncmp() 比较字符串的前几个字节
> 
> 声明  **int strncmp(const char \*str1, const char \*str2, size\_t n)**
> 
> 头文件 \#include<string.h>
> 
> 把 **str1** 和 **str2** 进行比较，最多比较前 **n个字节**
> 
>  *  如果返回值 < 0，则表示 str1 小于 str2。
>  *  如果返回值 > 0，则表示 str1 大于 str2。
>  *  如果返回值 = 0，则表示 str1 等于 str2。

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

## 4. 字符串查找  ##

### (1) strstr ###

> strstr() 在一个字符串中找另一个字符串的子串
> 
> 声明 **char \*strstr(const char \*haystack, const char \*needle)**
> 
> 头文件 \#incldue<string.h>
> 
> 在字符串 **haystack** 中查找第一次出现字符串 **needle** 的位置，不包含终止符 '\\0'。
> 
> 该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。

下面模拟实现库函数 strstr

//strstr模拟实现 找子字符串
    #include<stdio.h>
    #include<assert.h>
    char* my_strstr(const char* dest, const char* src)
    {
    	assert(dest && src);
    	const char* s1 = dest;
    	const char* s2 = src;
    	const char* cur = dest;
    	while (*cur)
    	{
    		s1 = cur;
    		s2 = src;
    		while (*s1 && *s2 && (*s1 == *s2))
    		{
    			s1++;
    			s2++;
    		}
    		if (*s2 == '\0')
    		{
    			return (char*)cur;
    		}
    		cur++;
    	}
    	return NULL;
    
    
    }
    int main()
    {
    	char str1[] = "abcdef";
    	char str2[] = "cde";
    	char* len=my_strstr(str1, str2);
    	if (NULL == len)
    	{
    		printf("找不到子串\n");
    	}
    	else
    	{
    		printf("%s\n", len);
    	}
    	return 0;
    }

### （2）strtok ###

> strtok()
> 
> 声明 char \* strtok ( char \* str, const char \* sep );
> 
> 头文件 \#include<stdio.h>
> 
> sep 参数是个字符串，定义了用作分隔符的字符集合 
> 
> 第一个参数指定一个字符串，它包含了 0 个或者多个由 sep 字符串中一个或者多个分隔符分割的标记
> 
> strtok函数会改变被操作的字符串，所以在使用strtok 函数切分的字符串一般都是临时拷贝的内容 
> 
> strtok 函数的第一个参数不为  NULL  ，函数将找到 str 中第一个标记， strtok 函数将保存它在字符串 
> 
> 中的位置。 
> 
> strtok 函数的第一个参数为  NULL  ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
> 
> 如果字符串中不存在更多的标记，则返回  NULL  指针。

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

## 5.内存操作函数  ##

### (1) memcpy  ###

> memcpy() 和strncpy特别像 但是 是实现内存上的拷贝
> 
> 声明 **void \*memcpy(void \*str1, const void \*str2, size\_t n)**
> 
> 头文件 \#include<string.h>
> 
> 从存储区 **str2** 复制 **n** 个字节到存储区 **str1**。

下面模拟实现库函数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--)
    	{
    		*(char*)dest = *(char*)src;
    		dest = (char*)dest + 1;
    		src = (char*)src + 1;
    	}
    	return ret;
    }
    
    
    int main()
    {
    	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    	int arr2[5] = { 0 };
    	my_memcpy(arr2, arr1, 20);
    
    
    	int i = 0;
    	int sz = sizeof(arr2) / sizeof(arr2[0]);
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr2[i]);
    	}
    
    
    	return 0;
    }

### (2) memmove ###

> memmove() 可以实现重叠内存的拷贝
> 
> 声明 **void \*memmove(void \*str1, const void \*str2, size\_t n)**
> 
> 头文件 \#include<string.h>
> 
> 从 **str2** 复制 **n** 个字符到 **str1**，但是在重叠内存块这方面，memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话，memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，复制后源区域的内容会被更改。如果目标区域与源区域没有重叠，则和 memcpy() 函数功能相同。

下面模拟实现库函数memmove

#define _CRT_SECURE_NO_WARNINGS 1
    #include<assert.h>
    #include<stdio.h>
    //模拟实现memmove
    void* my_memmove(void* dest, const void* src, size_t count)
    {
    	assert(dest && src);
    	void* ret = dest;
    	if (dest < src)
    	{
    		//前——>后
    		while (count--)
    		{
    			*(char*)dest = *(char*)src;
    			dest = (char*)dest + 1;
    			src = (char*)src + 1;
    		}
    	}
    	else
    	{
    		//后——>前
    		while (count--)
    		{
    			*((char*)dest + count) = *((char*)src + count);
    		}
    	}
    	return ret;
    }
    int main()
    {
    	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    	my_memmove(arr1 + 2, arr1, 20);
    	//my_memmove(arr1, arr1 + 2, 20);
    
    
    	int i = 0;
    	int sz = sizeof(arr1) / sizeof(arr1[0]);
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr1[i]);
    	}
    
    
    	return 0;
    }

### (3)memcmp ###

>  momcmp() 比较从ptr1和ptr2指针开始的num个字节 
> 
> 声明 **int memcmp(const void \*str1, const void \*str2, size\_t n)**
> 
> 头文件 \#include<string.h>
> 
> 把存储区 **str1** 和存储区 **str2** 的前 **n** 个字节进行比较。

### (4) memset ###

> memset() 以字节为单位初始化内存单元
> 
> 声明 **void \*memset(void \*str, int c, size\_t n)**
> 
> 头文件 \#include<string.h>
> 
> **参数**
> 
>  *  **str** \-- 指向要填充的内存块。
>  *  **c** \-- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
>  *  **n** \-- 要被设置为该值的字符数。

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

## 还有一些字符分类函数 ##

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th> 
    <div> 
     <span style="color:#333333;"><strong>如果他的参数符合下列条件就返回真 </strong></span> 
    </div> </th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">iscntrl </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">任何控制字符 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isspace</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">空白字符：空格</span> 
     <span style="color:#333333;">‘ ’</span> 
     <span style="color:#333333;">，换页</span> 
     <span style="color:#333333;">‘\f’</span> 
     <span style="color:#333333;">，换行</span> 
     <span style="color:#333333;">'\n'</span> 
     <span style="color:#333333;">，回车</span> 
     <span style="color:#333333;">‘\r’</span> 
     <span style="color:#333333;">，制表符</span> 
     <span style="color:#333333;">'\t'</span> 
     <span style="color:#333333;">或者垂直制表符</span> 
     <span style="color:#333333;">'\v' </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isdigit </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">十进制数字</span> 
     <span style="color:#333333;"> 0~9</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isxdigit </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">十六进制数字，包括所有十进制数字，小写字母</span> 
     <span style="color:#333333;">a~f</span> 
     <span style="color:#333333;">，大写字母</span> 
     <span style="color:#333333;">A~F</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">islower</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">小写字母</span> 
     <span style="color:#333333;">a~z</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isupper</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">大写字母</span> 
     <span style="color:#333333;">A~Z </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isalpha </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">字母</span> 
     <span style="color:#333333;">a~z</span> 
     <span style="color:#333333;">或</span> 
     <span style="color:#333333;">A~Z </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isalnum</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">字母或者数字，</span> 
     <span style="color:#333333;">a~z,A~Z,0~9</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">ispunct </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">标点符号，任何不属于数字或者字母的图形字符（可打印） </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isgraph</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">任何图形字符</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">isprint </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">任何可打印字符，包括图形字符和空白字符</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>