C语言：字符函数，字符串函数

在编程的过程中，我们经常要处理字符和字符串，为了方便操作字符和字符串，C语言标准库中提供了一系列库函数。

一. 字符分类函数

C语言中有一系列的函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的。 这些函数的使用都需要包含一个头文件件是 ctype.h

1. 函数       如果他的参数符合下列条件就返回真
    
2. iscntrl     任何控制字符
3. isspace  空白字符:空格'，换页“f，换行"n'，回车“r’，制表符"t'或者垂直制表符'v'
4. isdigit     十进制数字 '0’~'9’字符
5. isxdigit    十六进制数字，包括所有十进制数字字符，小写字母a~f，大写字母A~F
6. islower    小写字母a~z
7. isupper   大写字母A~Z
8. isalpha   字母a~z或A~Z
9. isalnum  字母或者数字，a~z,A~Z,0~9
10. ispunct   标点符号，任何不属于数字或者字母的图形字符(可打印)
11. isgraph   任何图形字符
12. isprint     任何可打印字符，包括图形字符和空白字符

接下来我们就举个例子

 写一个代码，将字符串中的小写字母转大写，其他字符不变。

既然要将小写字母转换为大写字母，那么我们就要找到小写字母，根据上面的函数我们知道判断是否为小写字母我们可以用islower函数，找到后我们就要进行转换，根据Ascll值可知小写到大写只需要减去32即可，这样我们就得到了我们的代码了。

#include <stdio.h>
#include <ctype.h>
int main()
{int i = 0;char str[] = "Test String.\n";char c;while (str[i]){c = str[i];if (islower(c))c -= 32;putchar(c);i++;}return 0;
}

二. 字符转换函数 

C语言提供了2个字符转换函数：

int tolower ( int c ); //将参数传进去的大写字母转小写

int toupper ( int c ); //将参数传进去的小写字母转大写

既然这样，那我们就可以利用toupper函数将上面的代码进行修改

#include <stdio.h>
#include <ctype.h>
int main()
{int i = 0;char str[] = "Test String.\n";char c;while (str[i]){c = str[i];if (islower(c))c = toupper(c);putchar(c);i++;}return 0;
}

三.字符串函数

1. strlen 的使用和模拟实现 

形式

size_t strlen ( const char * str );

• 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前⾯出现的字符个数（不包 含 '\0' )。
• 参数指向的字符串必须要以 '\0' 结束。
• 注意函数的返回值为 size_t，是无符号的。
• strlen的使用需要包含头文件，string.h

#include<stdio.h>
#include<string.h>
int main()
{char arr[] = "abcdef";size_t len = strlen(arr);printf("%zd\n", len);return 0;
}

strlen的模拟实现：

计数器的方式

#include<stdio.h>
int my_strlen(char* str)
{int count = 0;while (*str != '\0'){count++;str++;}return count;
}
int main()
{char arr[] = "abcdef";int len = my_strlen(arr);printf("%d\n", len);return 0;
}

指针-指针

#include<stdio.h>
#include<assert.h>
int my_strlen(char* str)
{char* pa = str;assert(str);while (*str != '\0'){str++;}return str - pa;
}
int main()
{char arr[] = "abcdef";int len = my_strlen(arr);printf("%d\n", len);return 0;
}

函数递归

#include<stdio.h>
#include<assert.h>
size_t my_strlen(char* str)
{assert(str);if (*str == '\0')return 0;elsereturn 1 + my_strlen(str + 1);}
int main()
{char arr[] = "abcdef";size_t len = my_strlen(arr);printf("%zd\n", len);return 0;
}

运行结果

 2.strcpy 的使用和模拟实现

形式

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

• 源字符串必须以 '\0' 结束。
• 会将源字符串中的 '\0' 拷贝到目标空间。 
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可修改。 

在使用strcpy函数时我们会创建两个数组arr1,arr2,如果我们想要将arr1中的内容拷贝到arr2中，首先我们创建的arr2要有足够大的空间，在strcpy函数中我们先存放的时目的地(arr2),然后存放源头(arr1),既strcpy(arr2, arr1);

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

既然我们已经了解了他的用法，那么就让我们模拟实现一下strcpy吧

模拟实现

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* str, const char* stc)
{char* ret = str;assert(str && stc);while (*str++ = *stc++){;}return ret;
}
int main()
{char arr1[] = "Hello World";char arr2[20] = { 0 };char* ret=my_strcpy(arr2, arr1);printf("%s\n",ret);return 0;
}

在函数中我们先将目标首地址赋给ret,然后进入循环将stc的值赋给str,并不断的向下走，直到为\0的时候停下，并将首地址返回。

3.strcat 的使用和模拟实现

形式 

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

• 将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加一个 \0 字 符。 
• 如果source 指向的字符串的长度小于num的时候，只会将字符串中到 \0 的内容追加到destination指向的字符串末尾。

#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<assert.h>
char* my_strcat(char* str,const char* stc)
{char* ret = str;assert(str && stc);while (*str != '\0')str++;while (*str++ = *stc++){;}return ret;
}
int main()
{char arr1[20] = "Hello ";char arr2[] = "World!";char* ret = my_strcat(arr1, arr2);printf("%s\n", ret);return 0;
}

我们先让目标地址找到\0，然后进入循环将stc的值赋给str,并不断的向下走，直到为\0的时候停下，并将首地址返回。

4.strcmp 的使用和模拟实现

形式

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

• 第⼀个字符串大于第二个字符串，则返回大于0的数字
• 第⼀个字符串等于第二个字符串，则返回0  
• 第⼀个字符串小于第二个字符串，则返回小于0的数字

实现原理

比较两个字符串中对应位置上字符ASCII码值的大小。

#include<stdio.h>
#include<string.h>
int main()
{char arr1[] = "abcdef";char arr2[] = "abcd";int ret =strcmp(arr1, arr2);printf("%d", ret);return 0;
}

 模拟实现

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp (const char * str1, const char * str2)
{int ret = 0;assert(str1 != NULL);assert(str2 != NULL);while (*str1 == *str2){if (*str1 == '\0')return 0;str1++;str2++;}return *str1 - *str2;
}
int main()
{char arr1[] = "abcdef";char arr2[] = "abcd";int ret = my_strcmp(arr1, arr2);printf("%d", ret);return 0;
}

只要指针指向的地方str1=str2就进行循环继续寻找，直到str1!=str2时退出循环返回*str1-*str2 ，或者*str1=='\0'就是全部比完了，没有差别，返回0。如果返回大于0的数就是大于，小于0的数就是小于，返回0就是等于。

根据前面的几个函数我们发现，我们都是在拷贝全部，追加全部，比较全部的字符，那么我们能不能控制拷贝，追加，比较的个数呢，其实时可以的，那么我们就来看一下下面的几个函数吧。

5.strncpy 的使用和模拟实现

形式

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

•  拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

诶，我们发现相较于strcpy函数strncpy函数只是多了个num，这其实就是对最大个数的限制

#include<stdio.h>
#include<string.h>
int main()
{char arr1[] = "Hello World!";char arr2[20] = { 0 };strncpy(arr2, arr1, 2);printf("%s", arr2);
}

 模拟实现 

#include<stdio.h>
char* my_strncpy(char* str1,const char* str2,int x)
{char* ret = str1;while (x){*str1++ = *str2++;x--;}return ret;
}
int main()
{char arr1[] = "Hello World!";char arr2[20] = { 0 };char* ret = my_strncpy(arr2, arr1, 2);printf("%s", ret);
}

当然，我们也可以发现对于个数的限制其实无非是对循环次数加以限制，因为我们要两个数所以只要进行两次循环即可，所以我们让x作为循环条件，每循环一次就减一，这样就成功实现了对个数的限制了，嘻嘻，看，我们也成功的只拷贝了两个字符了吧； 

6. strncat 的使用和模拟实现

形式

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

• 将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个 \0 字 符。 
• 如果source 指向的字符串的长度小于num的时候，只会将字符串中到 \0 的内容追加到destination指向的字符串末尾。

我们发现其实还是多了个num,对最大个数的限制。

#include<stdio.h>
#include<string.h>
int main()
{char arr1[20] = "Hello ";char arr2[] =  "World!";strncat(arr1, arr2, 2);printf("%s", arr1);return 0;
}

 模拟实现

#include<stdio.h>
char* my_strncat(char* str1,const char* str2, int x)
{char* ret = str1;while (*str1){str1++;}while (x){*str1++ = *str2++;x--;}return ret;
}
int main()
{char arr1[20] = "Hello ";char arr2[] =  "World!";char* ret = my_strncat(arr1, arr2, 2);printf("%s", ret);return 0;
}

相较于strcat函数的模拟实现strncat函数的模拟实现无非时对个数的限制也无非是对循环次数加以限制让x作为循环条件，每循环一次就减一，以实现我们想要的结果。

7. 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[] = "abccef";int ret =strncmp(arr1, arr2, 4);printf("%d", ret);return 0;
}

模拟实现 

#include<stdio.h>
#include<assert.h>
int my_strncmp(char* str1, const char* str2, int x)
{assert(str1 && str2);while (*str1 == *str2){if (*str1 == '\0'){return 0;}x--;if (x == 0){break;}str1++;str2++;}return *str1 - *str2;}
int main()
{char arr1[] = "abcdef";char arr2[] = "abccef";int ret = my_strncmp(arr1, arr2, 4);printf("%d", ret);return 0;
}

在我们上面学习的strcmp函数的基础上让x在循环中x--;并利用if语句让x=0时跳出循环，达到比较x个字符的目的。 

好了， 我们发现利用这几个函数我们实现了控制拷贝，追加，比较的个数，并且在我们的努力下模拟函数上也成功进行了个数的控制。

8. strstr 的使用和模拟实现

strstr 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回 str1字符串从 str2第一次出现的位置开始到 str1结尾的字符串；否则，返回NULL。

形式

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

• 函数返回字符串str2在字符串str1中第一次出现的位置
• 字符串的比较匹配不包含 \0 字符，以 \0 作为结束标志 

#include<stdio.h>
#include<string.h>
int main()
{char arr1[] = "abcdef";char arr2[] = "cde";char* ret=strstr(arr1, arr2);printf("%s",ret );return 0;
}

 模拟实现 

#include<stdio.h>
#include<assert.h>
char* my_strstr(char* str1, const char* str2)
{assert(str1 && str2);const char* s1 = str1;const char* s2 = str2;const char* cur = str1;while (*cur){s1 = cur;s2 = str2;while (*s1 && *s2 && *s1 == *s2){s1++;s2++;}if (*s2 == '\0'){return cur;}cur++;}return NULL;
}
int main()
{char arr1[] = "abcdef";char arr2[] = "cde";char* ret = my_strstr(arr1, arr2);printf("%s", ret);return 0;
}

1.首先先将两个字符串的地址传过去，给str1和str2，然后在函数中创建两个指针接收str1和str2的地址并且创建一个cur指针存放str1的首地址。

2.之后创建一个循环如*s1,*s2,*s1==*s2就让指针s1++,s2++,如果*s2=='\0'，就返回cur，因为一旦*s2=='\0'就证明字串全部找到了，就可以直接返回了。

3.但是要返回的 str1字符串是从 str2第一次出现的位置开始到 str1结尾的字符串根据代码我们要返回的是cdef，所以我们需要改变cur的起始地址，

所以我们在循环外再创建一个循环，循环条件为*cur，在循环里s1=cur,s2=str2,并且只要内循环条件不成立，就让cur++，并且重新给s1,s2赋值，但由于cur++,所以只要不等一次s1指针和cur指针就会向前移动一位，并且只要*cur!='\0'就能循环，一旦为'\0'就会退出循环返回NULL。

9.strtok 函数的使用

形式

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

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

#include <stdio.h>
#include <string.h>
int main()
{char arr[] = "zmingtao@115.com";char* sep = "@.";char* str = NULL;for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep)){printf("%s\n", str);}return 0;
}

10. strerror 函数的使用

形式

char* strerror ( int errnum );

strerror 函数可以把参数部分错误码对应的错误信息的字符串地址返回来。 在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在 errno.h 这个头文件中说明 的，C语言程序启动的时候就会使用⼀个全局的变量errno来记录程序的当前错误码，只不过程序启动 的时候errno是0，表示没有错误，当我们在使用标准库中的函数的时候发生了某种错误，就会将对应 的错误码，存放在errno中，而一个错误码的数字是整数很难理解是什么意思，所以每⼀个错误码都是 有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。

 打印⼀下0~10这些错误码对应的信息

#include <errno.h>
#include <string.h>
#include <stdio.h>
int main()
{int i = 0;for (i = 0; i <= 10; i++) {printf("%d: %s\n", i,strerror(i));}return 0;
}

我们可以看看vs中的结果 

当然我们也可看下例子，当然我们现在不用学习，只需要简单看下结果即可。

举例如果我们想要打开的文件 

#include <errno.h>
#include <string.h>
#include <stdio.h>
int main()
{FILE* pf = fopen("test.txt", "r");if (pf == NULL){printf("文件打开失败，原因是：");printf("%s\n", strerror(errno));return 1;}//打开成功// ....//关闭文件fclose(pf);pf = NULL;return 0;
}

当然我们也有一个函数能直接打印错误信息，并且再错误信息前会自动打印冒号和空格。

perror函数

他其实是由printf和strerror组成的。

#include <errno.h>
#include <string.h>
#include <stdio.h>
int main()
{FILE* pf = fopen("test.txt", "r");if (pf == NULL){perror("文件打开失败，原因是");return 1;}//打开成功// ....//关闭文件fclose(pf);pf = NULL;return 0;
}

好了今天的分享就到这里了，还请大家多多关注，我们下一篇见！