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

ゝ一世哀愁。 2024-04-07 15:14 72阅读 0赞

#### 文章目录 ####

*  字符函数和字符串函数
 *   *  前言
     *  字符函数介绍
     *   *  一.strlen
         *  二.strcpy
         *  三.strcat
         *  三.strcmp
         *  四.strncpy
         *  五.strncat
         *  六.strncmp
         *  七.strstr
         *  八.strtok
     *  字符分类函数
     *  内存操作函数
     *   *  一.memcpy
         *  二.memmove
         *  三.memcmp

## 字符函数和字符串函数 ##

**重点**

*  求字符串的长度
    
     *  strlen
 *  长度不受限制的字符串函数
    
     *  strcpy
     *  strcat
     *  strcmp
 *  长度不受限制的字符串函数的介绍
    
     *  strncpy
     *  strncat
     *  strncmp
 *  字符串查找
    
     *  strstr
     *  strtok
 *  错误信息报告
    
     *  strerror
 *  字符操作
 *  内存操作函数
    
     *  memcpy
     *  memmove
     *  memset
     *  memcmp

### 前言 ###

> C语言中对字符和字符串的处理很是频繁,但是C语言本身是没有字符串类型的,字符串通常放在`常量字符串中`或者`字符数组`中  
> `字符串常量`适用于那些对它不做修改的字符串函数

### 字符函数介绍 ###

#### [一.strlen][.strlen] ####

`size_t strlen ( const char * str );`

*  字符串已`\0`作为结束标志,strlen函数返回的是在字符串中`\0`前面出现的字符个数(不包含`\0`).
 *  参数指向的字符串必须要以`\0`结束
 *  注意函数的返回值是size\_t,是无符号的(`易错`)例如:

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
        if(strlen("abc") - strlen("abcdef") > 0) {
        
            printf("> \n");
        }else {
        
            printf("< \n");
        }
    }

> 当我们看到这里的时候以为是-3肯定是小于号,其实不然,返回值是无符号的所以返回的是无符号的-3,这个在内存中肯定是大于0的

#### [二.strcpy][.strcpy] ####

`char * strcpy ( char * destination, const char * source );`

*  源字符串必须以`\0`结束
 *  会将源字符串的`\0`拷贝到目标空间
 *  目标空间必须足够大,以确保能存放源字符串
 *  目标空间必须可变

以下是模拟实现的代码:

#include <stdio.h>
    #include <assert.h>
    
    char* my_strcpy(char* dest,const char* src) {
        
        assert(dest);
        assert(src);
        char* ret = dest;
        while(*dest++ = *src++);
        return ret;
    }
    
    int main() {
        
        char arr1[20] = "abc";
        char arr2[] = "hello world!";
        printf("%s\n", my_strcpy(arr1,arr2));
        return 0;
    }

#### [三.strcat][.strcat] ####

`char * strcat ( char * destination, const char * source );`

*  源字符串必须以`\0`结束
 *  目标空间必须有足够的大,能容纳下源字符串的内容
 *  目标空间必须可修改

使用场景:

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
        char arr1[20] = "hello ";
        char arr2[] = "world!";
        strcat(arr1, arr2);
        printf("%s\n", arr1);
        return 0;
    }

这个函数的模拟实现:

#include <stdio.h>
    #include <string.h>
    
    char* my_strcat(char* dest, const char* src) {
        
        char* cur = dest;
        while(*++cur != '\0');
        while(*cur++ = *src++);
        return dest;
    }
    
    int main() {
        
        char arr1[20] = "hello ";
        char arr2[] = "world!";
        my_strcat(arr1, arr2);
        printf("%s\n", arr1);
        return 0;
    }

#### [三.strcmp][.strcmp] ####

`int strcmp ( const char * str1, const char * str2 );`

*  标准规定:

1.  第一个字符串大于第二个字符串,则返回大于0的数字
2.  第一个字符串等于第二个字符串,则返回0
3.  第一个字符串小于第二个字符串则返回小于0的数字

模拟实现:

#include <stdio.h>
    #include <string.h>
    
    int my_strcmp(const char* src1, const char* src2) {
        
        while(*src1 == *src2) {
        
            if(*src1 == '\0') {
        
                return 0;
            }
            src1 ++;
            src2 ++;
        }
        return src1 - src2;
    }
    
    int main() {
        
        char arr1[] = "abcdef";
        char arr2[] = "abc";
        int ret = my_strcmp(arr1, arr2);
        printf("%d\n", ret);
    }

#### [四.strncpy][.strncpy] ####

`char * strncpy ( char * destination, const char * source, size_t num );`

*  拷贝num个字符从源字符串到目标空间
 *  如果源字符串的长度小于num,则拷贝完源字符串后,在目标的后面追加0,知道num个  
    使用场景:

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
        char arr1[] = "abcef";
        char arr2[] = "xxxxxx";
        strncpy(arr1, arr2, 2);
        printf("%s\n", arr1);
    }

#### [五.strncat][.strncat] ####

`char * strncat ( char * destination, const char * source, size_t num );`  
这个函数的功能就是追加有长度限制的个数,使用场景:

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
        char arr1[] = "abcdef";
        char arr2[] = "xxx";
        strncat(arr1, arr2, 2);
        printf("%s\n", arr1);
    }

#### [六.strncmp][.strncmp] ####

`int strncmp ( const char * str1, const char * str2, size_t num );`

比较有限制长度的两个字符串使用场景:

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
        char arr1[] = "abcdef";
        char arr2[] = "abc";
        int ret = strncmp(arr1, arr2, 3);
        printf("%d\n", ret);
    }

#### [七.strstr][.strstr] ####

`char * strstr ( const char *, const char * );`

> 这个函数的功能就是在一个字符串中找另一个字符串是否存在

使用场景:

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
        char arr1[] = "abcdefabcdef";
        char arr2[] = "fab";
        char* p = strstr(arr1, arr2);
        if(p == NULL) {
        
            printf("不存在\n");
        }else {
        
            printf("%s\n", p);
        }
    }

模拟实现:

#include <stdio.h>
    #include <string.h>
    
    char* my_strstr(char* str1, char* str2) {
        
        char* s1 = str1;
        char* s2 = str2;
        char* p = str1;
        while(*p) {
        
            s1 = p;
            s2 = str2;
            if(*str2 == '\0') {
        
                return str1;
            }
            while(*s1 != '\0' && *s2 != '\0' && (*s1 == *s2)) {
        
                s1 ++;
                s2 ++;
            }
            if(*s2 == '\0') {
        
                return p;
            }
            p ++;
        }
        return NULL;
    }
    
    int main() {
        
        char arr1[] = "abcdefabcdef";
        char arr2[] = "fab";
        char* p = my_strstr(arr1, arr2);
        if(p == NULL) {
        
            printf("不存在\n");
        }else {
        
            printf("%s\n", p);
        }
    }

#### [八.strtok][.strtok] ####

`char * strtok ( char * str, const char * delimiters );`

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

使用场景：

#define _CRT_SECURE_NO_WARNINGS
    
    #include <stdio.h>
    #include <string.h>
    
    int main() {
        
    	char arr[] = "zhangyang@qq.com";
    	char buf[200] = {
         0 };
    	strcpy(buf, arr);
    	const char* p = "@.";
    	char* str = strtok(buf, p);
    	printf("%s\n", str);
    	str = strtok(NULL, p);
    	printf("%s\n", str);
    	str = strtok(NULL, p);
    	printf("%s\n", str);
    	return 0;
    }

上面那个写法比较庸俗，我们用更优雅的方式：

#define _CRT_SECURE_NO_WARNINGS
    
    #include <stdio.h>
    #include <string.h>
    
    int main() {
        
    	char arr[] = "zhangyang@qq.com";
    	char buf[200] = {
         0 };
    	strcpy(buf, arr);
    	const char* p = "@.";
    	char* str = NULL;
    	for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p)) {
        
    		printf("%s\n", str);
    	}
    	return 0;
    }

### 字符分类函数 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>如果它的参数满足下列条件就返回</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>iscntrl</td> 
   <td>任何控制字符</td> 
  </tr> 
  <tr> 
   <td>isspace</td> 
   <td>空白字符：空格‘ ’，换页‘\f’， 换行‘\n’, 回车‘\r’，制表符‘\t’，或者垂直制表符‘\v’</td> 
  </tr> 
  <tr> 
   <td>isdigit</td> 
   <td>十进制数字0–9</td> 
  </tr> 
  <tr> 
   <td>isxdigit</td> 
   <td>十六进制数字，包括所有十进制数字，小写字母a-f， 大写字母A-F</td> 
  </tr> 
  <tr> 
   <td>islower</td> 
   <td>小写字母a-z</td> 
  </tr> 
  <tr> 
   <td>isupper</td> 
   <td>大写字母A-Z</td> 
  </tr> 
  <tr> 
   <td>isalpha</td> 
   <td>字母a-z或者A-Z</td> 
  </tr> 
  <tr> 
   <td>isalnum</td> 
   <td>字母或者数字</td> 
  </tr> 
  <tr> 
   <td>ispunct</td> 
   <td>标点符号，任何不属于数字或字母的图形字符（可打印）</td> 
  </tr> 
  <tr> 
   <td>isgraph</td> 
   <td>任何图形字符</td> 
  </tr> 
  <tr> 
   <td>isprint</td> 
   <td>任何可打印字符，包括图形字符和空白字符</td> 
  </tr> 
 </tbody> 
</table>

### 内存操作函数 ###

#### [一.memcpy][.memcpy] ####

`void * memcpy ( void * destination, const void * source, size_t num );`

*  函数从source的位置开始向后复制num个字节的数据到destinatio中去
 *  这个函数在遇到`\0`的时候并不会停下来
 *  如果source和destinat有任何的重叠复制的结果都是未定义的

使用场景：

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
    	int arr1[] = {
         1,2,3,4,5,6,7,8 };
    	int arr2[20] = {
         0 };
    	memcpy(arr2, arr1, sizeof(arr1[0]) * 3);
    	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
        
    		printf("%d ", arr2[i]);
    	}
    	return 0;
    }

模拟实现：

#include <stdio.h>
    #include <string.h>
    
    int main() {
        
    	int arr1[] = {
         1,2,3,4,5,6,7,8 };
    	int arr2[20] = {
         0 };
    	memcpy(arr2, arr1, 12);
    	for (int i = 0; i < 3; i++) {
        
    		printf("%d ", arr2[i]);
    	}
    }

#### [二.memmove][.memmove] ####

`void * memmove ( void * destination, const void * source, size_t num );`

> 我们发下这个函数和上一个函数的参数和返回类型是一样的，但是还是有点区别的
> 
> 1.  memcpy拷贝的是不重复的内存
> 2.  memmove是可以拷贝重复的内存的

模拟实现：

#include <stdio.h>
    #include <string.h>
    
    
    void* my_memcpy(void* dest, void* src, size_t num) {
        
    	void* ret = dest;
    	if (dest < 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 };
    	int arr2[20] = {
         0 };
    	my_memcpy(arr2, arr1, sizeof(arr1[0]) * 3);
    	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++) {
        
    		printf("%d ", arr2[i]);
    	}
    	return 0;
    }

> 加上了一个新的比较，这样就可以实现重叠内存的拷贝

#### [三.memcmp][.memcmp] ####

`int memcmp ( const void * ptr1, const void * ptr2, size_t num );`

*  比较从ptr1和ptr2指针开始的num个字节
 *  返回值如下：  
    ![在这里插入图片描述][8de48dedba1447488e138a841d1a20a6.png]  
    **注意**是按照一个字节一个字节去比较的

[.strlen]: https://cplusplus.com/reference/cstring/strlen/?kw=strlen
[.strcpy]: https://cplusplus.com/reference/cstring/strcpy/
[.strcat]: https://cplusplus.com/reference/cstring/strcat/
[.strcmp]: https://legacy.cplusplus.com/reference/cstring/strcmp/?kw=strcmp
[.strncpy]: https://legacy.cplusplus.com/reference/cstring/strncpy/?kw=strncpy
[.strncat]: https://legacy.cplusplus.com/reference/cstring/strncat/?kw=strncat
[.strncmp]: https://legacy.cplusplus.com/reference/cstring/strncmp/?kw=strncmp
[.strstr]: https://legacy.cplusplus.com/reference/cstring/strstr/?kw=strstr
[.strtok]: https://cplusplus.com/reference/cstring/strtok/
[.memcpy]: https://legacy.cplusplus.com/reference/cstring/memcpy/?kw=memcpy
[.memmove]: https://cplusplus.com/reference/cstring/memmove/
[.memcmp]: https://legacy.cplusplus.com/reference/cstring/memcmp/?kw=memcmp
[8de48dedba1447488e138a841d1a20a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/4c8b526d149a43c484bdb1483ec7f17f.png