03-C语言进阶——字符函数和字符串函数

Bertha 。 2022-12-23 00:50 281阅读 0赞

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

*  一、字符串操作函数
 *   *  1.求字符串长度
     *   *  1.1 strlen
     *  2. 长度不受限制的字符串
     *   *  2.1 strcpy
         *  2.2 strcat
         *  2.3 strcmp
     *  3.长度受限制的字符串函数介绍
     *   *  3.1 strncpy
         *  3.2 strncat
         *  3.3 strncmp
     *  4.字符串查找
     *   *  4.1 strstr
         *  4.2 strtok
     *  5.错误信息报告
     *   *  5.1 strerror
 *  二、字符操作
 *   *  1.字符分类函数
     *  2.字符转换
 *  三、内存操作函数
 *   *  1.memcpy
     *  2.memmove
     *  3.memset
     *  4.memcmp

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

# 一、字符串操作函数 #

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

### 1.1 strlen ###

size_t strlen(const char *str);

*  字符串以 **‘\\0’** 作为结束标志，strlen函数返回的是在**字符串中 ‘\\0’ 前面出现的字符个数**。  
    **注意**：这里不包含’\\0’，例如"abc",使用strlen返回的值就是3。
 *  参数指向的字符串必须要以 ‘\\0’ 结束。  
    **注意**：函数的返回值为size\_t，是**无符号整数**（ 易错 ），举个例子：

int main()
    {
        
        const char*str1 = "abcdef";
        const char*str2 = "bbb";
        if(strlen(str2)-strlen(str1)>0)
        {
        
            printf("str2>str1\n");
        } 
        else
        {
        
            printf("srt1>str2\n");
        }
        return 0;
    }

结果![在这里插入图片描述][20201124095534117.png_pic_center]  
原因：strlen返回值为无符号整形，因此不会出现负数情况，也就不会出现小于0的情况。

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

### 2.1 strcpy ###

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

*  将source指向的C字符串复制到目标指向destination的数组中，**包括’\\0’**。  
    **注意：**
 *  源字符串必须以’\\0’结束。
 *  会将字符串中的’\\0’拷贝到目标空间。
 *  目标空间必须足够大，以确保能存放源字符串。
 *  目标空间必须可变。
 *  source不会被修改，只能被读取，所以使用const。

### 2.2 strcat ###

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

*  将源的第字符追加到目标字符后面，加上一个终止的空字符\\0，例如源字符串"123\\0",目标字符串"abc\\0",则追加后"abc123\\0"
 *  如果源中的C字符串长度小于num，则仅复制直到终止空字符的内容。
 *  源字符串必须以 ‘\\0’ 结束。
 *  目标空间必须有足够的大，能容纳下源字符串的内容。
 *  目标空间必须可修改。

### 2.3 strcmp ###

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

**如何比较两个字符串大小？**  
该函数比较每个字符串的第一个字符。如果它们相等，继续比较第二个字符，直到字符不同或’\\0’字符为止。**字符串的大小与长度无关。**  
**字符比较的原则**为**ascll表的码值**，如下图所示。例如：“abc”，“abd”,前两个字符a，b的ascll码值相同，比较c和d，可以得出c=99<d=100，因此"abd">“abc”。  
![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2bKa0lBl-1606184717461)(https://baike.baidu.com/pic/ASCII/309296/1/e850352ac65c103880a07b53bc119313b17e8941?fr=lemma\#aid=1&pic=e850352ac65c103880a07b53bc119313b17e8941\#pic\_center)\]][img-2bKa0lBl-1606184717461_https_baike.baidu.com_pic_ASCII_309296_1_e850352ac65c103880a07b53bc119313b17e8941_fr_lemma_aid_1_pic_e850352ac65c103880a07b53bc119313b17e8941_pic_center]  
这里需要注意的是strcmp返回值：

*  标准规定：
    
     *  第一个字符串大于第二个字符串，则返回大于0的数字
     *  第一个字符串等于第二个字符串，则返回0
     *  第一个字符串小于第二个字符串，则返回小于0的数字  
        例子：

const char * str1 = "abc";
    const char * str2 = "abc";
    
    if (strcmp(str1, str2))
    {
        
    	printf("相等\n");
    }
    else
    {
        
    	printf("不相等\n");
    }

结果：![在这里插入图片描述][20201124104242321.png_pic_center]  
**原因：如果两个字符串相等，strcmp的返回值为0。正确写法如下**：

const char * str1 = "abc";
    const char * str2 = "abc";
    
    if (strcmp(str1, str2)==0)
    {
        
    	printf("相等\n");
    }
    else
    {
        
    	printf("不相等\n");
    }

结果：![在这里插入图片描述][20201124104535222.png_pic_center]

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

### 3.1 strncpy ###

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

将源的前几个字符复制到目标。如果源C字符串的末尾(由空字符表示)是在复制数字字符之前找到的，目标将被填充零，直到总共有数字字符被写入其中。  
拷贝num个字符从源字符串到目标空间。  
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

### 3.2 strncat ###

char * strncat( char * destination, const char * source, size_t num);

将源的前几个字符追加到目标，加上一个终止的空字符。如果源中的C字符串长度小于num，则仅复制直到终止空字符的内容。

**注意：** **strncpy不会自动添加’\\0’，而strncat会自动添加’\\0’**。  
例子：

char str1[20];
    char str2[20];
    strcpy(str1, "To be ");
    strcpy(str2, "or not to be");
    strncat(str1, str2, 6);
    puts(str1);

结果：![在这里插入图片描述][20201124111246197.png_pic_center]  
这里需要了解puts函数

int puts ( const char * str );

C语言默认有三个输入输出函数

*  stdin：标准输入->键盘
 *  stdout：标准输出->显示器
 *  stderror：标准错误->显示器

**puts与printf区别：**

puts("hello world %d\n");
    	printf("hello world %d\n", 10);

![在这里插入图片描述][20201124112139877.png_pic_center]  
puts默认带一个"\\n"。

### 3.3 strncmp ###

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。  
例子：

char str[][5] = {
         "R2D2","B7UD","R2O9" };
    int n;
    puts("Looking for R2 astromech droids...");
    for (n = 0; n < 3; n++)
    {
        
    	if (strncmp(str[n], "R2xx", 2) == 0)
    	{
        
    		printf("founds %s\n",str[n]);
    	}
    }

结果：![在这里插入图片描述][20201124151225685.png_pic_center]

## 4.字符串查找 ##

### 4.1 strstr ###

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

返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回空指针  
例子：

char str[] = "This is a simple string.";
    char *pch;
    pch = strstr(str, "simple");
    strncpy(pch, "sample", 6);
    puts(str);

结果：![在这里插入图片描述][20201124151621735.png_pic_center]

### 4.2 strtok ###

char * strtok( char * str, const char * sep)

*  sep参数是个字符串，定义了用作分隔符的字符集合。
 *  第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
 *  strtok函数找到str中的下一个标记，并将其用 \\0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
 *  strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
 *  strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
 *  如果字符串中不存在更多的标记，则返回 NULL 指针。  
    **注意：strtok是用来进行字符串分割的，首次调用需要传入字符串起始地址，后续调用设为NULL即可，调一次拿一个字符串。**  
    例子：以@和.分隔字符串

char *p = "kyrieleon@gmail.com";
    	const char* sep = ".@";
    	char arr[30];
    	char *str = NULL;
    	strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
    	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    	{
        
    		printf("%s\n", str);
    	}

结果：![在这里插入图片描述][20201124152759745.png_pic_center]

## 5.错误信息报告 ##

### 5.1 strerror ###

char * strerror(int errnum);

调用该函数必须包含头文件

#include<errno.h>

返回错误码，所对应的错误信息。  
例子：查看windows下的错误码对应的信息

for (int i = 1; i < 50; i++)
    {
        
    	printf("%d->%s\n", i, strerror(i));
    }

结果：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70_pic_center]

# 二、字符操作 #

## 1.字符分类函数 ##

字符操作判断的为单个字符的结果，需要与字符串区分，不要混淆。

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>如果他的参数符合下列条件就返回真</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>iscntrl</td> 
   <td>任何控制字符</td> 
  </tr> 
  <tr> 
   <td><strong>isspace</strong></td> 
   <td>空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’</td> 
  </tr> 
  <tr> 
   <td><strong>isdigit</strong></td> 
   <td>十进制数字 0~9</td> 
  </tr> 
  <tr> 
   <td>isxdigit</td> 
   <td>十六进制数字，包括所有十进制数字，小写字母a<sub>f，大写字母A</sub>F</td> 
  </tr> 
  <tr> 
   <td><strong>islower</strong></td> 
   <td>小写字母a~z</td> 
  </tr> 
  <tr> 
   <td><strong>isupper</strong></td> 
   <td>大写字母A~Z</td> 
  </tr> 
  <tr> 
   <td>isalpha</td> 
   <td>字母a<sub>z或A</sub>Z</td> 
  </tr> 
  <tr> 
   <td>isalnum</td> 
   <td>字母或者数字，a<sub>z,A</sub>Z,0~9</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>

例子：判断字符c是否为空格

char c = ' ';
    if (isspace(c))
    {
        
    	printf("c为空格\n");
    }

![在这里插入图片描述][20201124153615553.png_pic_center]

## 2.字符转换 ##

int tolower ( int c );
    int toupper ( int c );

例子：将字符串中大写字母转化为小写字母

int i = 0;
    char str[] = "Test String.\n";
    char c;
    while (str[i])
    {
        
    	c = str[i];
    	if (isupper(c))
    		c = tolower(c);
    	putchar(c);
    	i++;
    }

![在这里插入图片描述][20201124154309158.png_pic_center]

# 三、内存操作函数 #

注意：**内存拷贝操作的基本单元是字节，与类型无关。** 实例见memset操作函数的例子

## 1.memcpy ##

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

*  函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
 *  **不同于字符串拷贝函数strcpy，这个函数在遇到 ‘\\0’ 的时候并不会停下来，而是准确的复制num个字节。**
 *  如果source和destination有任何的重叠，复制的结果都是未定义的  
    memcpy可以拷贝结构体，例如：

struct {
        
    		char name[16];
    		int age;
    	}person,person_copy;
    
    	char myname[] = "kyrie";
    	memcpy(person.name, myname, strlen(myname) + 1);
    	person.age = 46;
    
    	/* using memcpy to copy structure: */
    	memcpy(&person_copy, &person, sizeof(person));
    
    	printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);

![在这里插入图片描述][20201124160127788.png_pic_center]

这里需要注意的是**memcpy传入的是地址**

## 2.memmove ##

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

## 3.memset ##

void * memset ( void * ptr, int value, size_t num );

ptr：为指针或是数组,  
value：是赋给ptr的值,  
num：是ptr的长度.  
这里需要记住：mem操作的基本单元是字节，与类型无关  
例子：

int a[5] = {
         0 };
    memset(a, 1, sizeof(a));
    for (int i = 0; i < 5; i++)
    	printf("a[%d]=%d\n", i, a[i]);

**误区**：将整形数组a的每个值赋1 ，这种理解错误  
正确理解：对整形数组a的每个字节赋1  
![在这里插入图片描述][20201124162827672.png_pic_center]  
![在这里插入图片描述][20201124162420760.png_pic_center]

## 4.memcmp ##

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

比较从ptr1和ptr2指针开始的num个字节  
例子：比较两个字符串大小

char buffer1[] = "DWgaOtP12df0";
    char buffer2[] = "DWGAOTP12DF0";
    
    int n;
    
    n = memcmp(buffer1, buffer2, sizeof(buffer1));
    
    if (n>0) printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
    else if (n<0) printf("'%s' is less than '%s'.\n", buffer1, buffer2);
    else printf("'%s' is the same as '%s'.\n", buffer1, buffer2);

![在这里插入图片描述][20201124161435264.png_pic_center]

[20201124095534117.png_pic_center]: /images/20221120/bc5defb6af524ed8ab661f51c3f77fa8.png
[img-2bKa0lBl-1606184717461_https_baike.baidu.com_pic_ASCII_309296_1_e850352ac65c103880a07b53bc119313b17e8941_fr_lemma_aid_1_pic_e850352ac65c103880a07b53bc119313b17e8941_pic_center]: /images/20221120/156dcfc696db42e99bedced5c2f5cfbc.png
[20201124104242321.png_pic_center]: /images/20221120/b774c43ddb6641a093e4b4613b7c6707.png
[20201124104535222.png_pic_center]: /images/20221120/fc9f6b8177ea426e8ccf59e632f359e6.png
[20201124111246197.png_pic_center]: /images/20221120/0b19d67c5aad43f4a3995d3bac023c1f.png
[20201124112139877.png_pic_center]: /images/20221120/d5b36b58f4684ab5923f0ef88219e2bc.png
[20201124151225685.png_pic_center]: /images/20221120/56df3bc904e04525abd41ed3256b4db2.png
[20201124151621735.png_pic_center]: /images/20221120/b48f330b416745cca509eb7726b83ef4.png
[20201124152759745.png_pic_center]: /images/20221120/56327efa26374494bb4af7939061fb1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/b66f1d3a0af845e18ffc8413a60c935b.png
[20201124153615553.png_pic_center]: /images/20221120/0e5dabd620404dd2b4b8001e24789f1a.png
[20201124154309158.png_pic_center]: /images/20221120/b471da3a8b044532a87433c5e390174b.png
[20201124160127788.png_pic_center]: /images/20221120/ae30fd6d9fec4f70bb0d44e4d5c3f651.png
[20201124162827672.png_pic_center]: /images/20221120/bc223ab0336e40b98c4ea223c6775ab6.png
[20201124162420760.png_pic_center]: /images/20221120/80755428c4eb40b28d3448da069e43cf.png
[20201124161435264.png_pic_center]: /images/20221120/3d712722a1d64325b1a5d49bebec6260.png