一.求字符串长度
1.strlen()
(1)基本概念
头文件：<string.h>
(2)易错点：strlen()的返回值为无符号整形
cpp
#include<stdio.h>
#include<string.h>
int main()
{
const char* str1 = "abcdef";
const char* str2 = "bbb";
printf("%u\n", strlen(str2) - strlen(str1));
printf("%d\n", strlen(str2) - strlen(str1));
return 0;
}
两个strlen函数的返回值相减，得到的结果为无符号整数的形式
cpp
#include<stdio.h>
#include<string.h>
int main()
{
const char* str1 = "abcdef";
const char* str2 = "bbb";
if (strlen(str2) - strlen(str1) > 0)
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}
(3)模拟实现
cpp
#include<stdio.h>
#include<string.h>
size_t my_strlen(const char* str1)
{
size_t count=0;
while (*str1++)
{
count++;
}
return count;
}
int main()
{
const char* str1 = "abcdef";
size_t len=my_strlen(str1);
printf("%u",len);
return 0;
}
二.长度不受限制的字符串函数
1.strcpy()------将源字符串复制给目标字符串
(1)基本概念
头文件：<string.h>
cpp
#include<stdio.h>
#include<string.h>
int main()
{
char name[20] = {0};
//目标字符串的空间要足够大，否则会出现数组越界现象
char arr[20] = "hhhhhhhhhh";
strcpy(name,arr);
//arr为字符串首元素的地址
//strcpy(目标字符串首元素地址，字符串常量首元素地址)
//'\0'也会被复制到目标字符串
printf("%s\n",name);
strcpy(name,"ycy");
printf("%s",name);
return 0;
}(2)易错点：目标空间不够大时,字符串的复制还是会进行,代价是通过数组越界来实现的
(3)模拟实现
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcpy(char* name,char* arr)
{
assert(name&&arr);
char* p = name;
while (*name++=*arr++) //赋值语句的返回值为左操作数的值，当*arr将'\0'赋值给*name时结束循环
{
}
return p;
}
int main()
{
char name[20] = {0};
char arr[20] = "hhhhhhhhhh";
my_strcpy(name,arr);
printf("%s",name);
return 0;
}
2.strcat()------字符串追加
(1)基本概念
头文件<string.h>
(2)模拟实现
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* arr1,char* arr2)
{
char* p = arr1;
//将地址移动至\0处
while (*arr1)
{
arr1++;
}
//从\0处开始拷贝arr2
//h e l l o \0------arr1
// w o r l d \0------arr2
//h e l l o w o r l d \0 ------追加后的arr1
while (*arr1++ = *arr2++)
{
}
return p;
}
int main()
{
char arr1[20] = "hello";
char arr2[20] = " world";
my_strcat(arr1,arr2);
printf("%s",arr1);
return 0;
}3.strcmp()------字符串比较
(1)基本概念
头文件<string.h>
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char arr1[20] = "hello";
char arr2[20] = "world";
int p=strcmp(arr1,arr2);
//strcmp函数会将两个字符串的每个字符依次比较
//若出现不相等则停止比较
//前一个操作符的元素大于后一个操作符的元素，则会输出一个大于零的整数
//前一个操作符的元素小于后一个操作符的元素，则会输出一个小于零的整数、
//等于则输出0
if (p > 0)
{
printf("arr1>arr2\n");
}
else if (p == 0)
{
printf("arr1==arr2\n");
}
else
{
printf("arr1<arr2\n");
}
return 0;
}(2)模拟实现
cpp
include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp(char* arr1,char* arr2)
{
assert(arr1&&arr2);
while (*arr1==*arr2) //相同的情况下，判断下一位是否也相同，不相同则退出循环
{
if (*arr1=='\0'||*arr2=='\0') //若有其中一个字符串到达末尾，则退出循环
{
break;
}
arr1++;
arr2++;
}
return *arr1 - *arr2; //不相同则相减返回差值
}
int main()
{
char arr1[20] = "hello";
char arr2[20] = "hello";
int p=my_strcmp(arr1,arr2);
if (p > 0)
{
printf("arr1>arr2\n");
}
else if (p == 0)
{
printf("arr1==arr2\n");
}
else
{
printf("arr1<arr2\n");
}
return 0;
}三.长度受限制的字符串函数介绍
1.strncpy() ------可控制，复制字符串元素
(1)基本概念
头文件<string.h>
cpp
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "abcdef";
char arr2[] = "bit";
strncpy(arr1,arr2,3);
printf("%s\n",arr1);
return 0;
}(2)易错点：当要复制的元素个数大于原字符串时，多出来的位置会用\0代替
cpp
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "abcdef";
char arr2[] = "bit";
strncpy(arr1,arr2,5);
printf("%s\n",arr1);
return 0;
}(3)模拟实现
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncpy(char* arr1,char* arr2,size_t x)
{
assert(arr1&&arr2);
char *p= arr1;
int i;
int len = strlen(arr2);
for (i = 0; i < x; i++)
{
if (i>len)
{
*arr1++ = '\0';
}
else
{
*arr1++ = *arr2++;
}
}
return p;
}
int main()
{
char arr1[20] = "abcdef";
char arr2[] = "bit";
my_strncpy(arr1,arr2,5);
printf("%s\n",arr1);
return 0;
}2.strncat()------可控制，链接字符串元素
(1)基本概念
头文件<string.h>
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char arr1[20] = "hello";
char arr2[] = "bit";
strncat(arr1,arr2,3);
printf("%s\n",arr1);
return 0;
}(2)易错点：需要链接的元素个数小于原字符串时，会在链接相应数量元素的同时多链接一个'\0' .元素个数大于原字符串时，不会用'\0'填补
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char arr1[20] = "hello";
char arr2[] = "bit";
strncat(arr1,arr2,5);
printf("%s\n",arr1);
return 0;
}
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char arr1[20] = "hello";
char arr2[] = "bit";
strncat(arr1,arr2,1);
printf("%s\n",arr1);
return 0;
}(3)模拟实现
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncat(char* arr1,char*arr2,size_t x)
{
assert(arr1&&arr2);
int len = strlen(arr2);
char* p = arr1;
while (*arr1 != '\0')
{
arr1++;
}
if (x >= len)
{
while (*arr2)
{
*arr1++ = *arr2++;
}
}
else
{
for (int i = 0; i < x; i++)
{
*arr1++ = *arr2++;
}
*arr1 = '\0';
}
return p;
}
int main()
{
char arr1[20] = "hello";
char arr2[] = "bit";
my_strncat(arr1,arr2,5);
printf("%s\n",arr1);
return 0;
}3.strncmp()------可控制，比较字符串元素
(1)基本概念
头文件<string.h>
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char arr1[20] = "hello";
char arr2[] = "bit";
int ret=strncmp(arr1,arr2,3);
if (ret > 0)
{
printf("arr1>arr2");
}
else if (ret == 0)
{
printf("arr1==arr2");
}
else
{
printf("arr1<arr2");
}
return 0;
}四.字符串查找
1.strstr()------在一个字符串中查找另一个字符串是否存在
(1)基本概念
头文件<string.h>
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char arr1[20] = "hello bit world";
char arr2[] = "bit";
char*ret = strstr(arr1,arr2);//ret为寻找到字串位置的首地址
if (ret == NULL)
{
printf("所寻找的子串不存在\n");
}
else
{
printf("%s",ret);//从地址处往后输出
}
return 0;
}(2)模拟实现
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1&&str2); //判断参数不为空
const char* s1 = str1;
const char* s2 = str2;
const char* p = str1;
while (*p) //被查找的字符串不为空
{
s1 = p;
s2 = str2; //始终指向查找字符串的首元素地址
while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) //都不为空且相等时进入循环
{
s1++;
s2++;
}
if (*s2 == '\0') //如果退出循环时查找字符串到最后都是相等的，则说明查找成功
{
return p; //返回查找到的首地址
}
p++; //若查找途中存在不相同的，则被查找字符串指针向后一位
}
return NULL;
}
int main()
{
char arr1[20] = "hello bit world";
char arr2[] = "bit";
char* ret = my_strstr(arr1, arr2);//ret为寻找到字串位置的首地址
if (ret == NULL)
{
printf("所寻找的子串不存在\n");
}
else
{
printf("%s", ret);//从地址处往后输出
}
return 0;
}
2.strtok()------切割字符串
(1)基本概念
头文件<string.h>
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
const char* sep = '@'; //分隔符
char email[] = "zhangpengwei@bietejieyeke.com"; //被分割的字符串
strtok(email,sep); //因为strtok函数会将遇到的第一个分隔符改为'\0'，
//并返回分隔符的指针,将改变原有字符串
//__________________________________________________________________________________
//若不想原有字符串被改变则采用如下操作
char cp[] = {0};
strcpy(cp,email);
strtok(cp,sep);
return 0;
}(2)简单应用
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
const char* sep = "@."; //分隔符
char email[] = "zhangpengwei@bietejieyeke.com"; //被分割的字符串
char cp[30] = {0};
strcpy(cp,email); //strtok函数有记忆功能，执行完后会保存上一个分隔符的地址，下一次调用时从该地址往后查找
char* ret=strtok(cp,sep);
printf("%s\n",ret);
ret = strtok(NULL,sep); //所以除第一次调用，多次调用时不需要传入参数，所以传入NULL
printf("%s\n", ret);
ret = strtok(NULL, sep);
printf("%s\n", ret);
return 0;
}(3)优化
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
const char* sep = "@."; //分隔符
char email[] = "zhangpengwei@bietejieyeke.com"; //被分割的字符串
char cp[30] = {0};
strcpy(cp,email);
char* ret = NULL;
for (ret = strtok(cp, sep); ret != NULL; ret=strtok(NULL, sep))
{
printf("%s\n",ret);
}
return 0;
}五.错误信息报告
1.strerror()------返回错误码所对应的错误信息
(1)基本概念
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
//c语言的库函数在执行失败的时候，都会设置相应的错误码
//0 1 2 3 4 5 6 7 8 ......
//strerror()可以返回错误码所对应的错误信息
printf("%s\n", strerror(1));
printf("%s\n", strerror(2));
printf("%s\n", strerror(3));
printf("%s\n", strerror(4));
printf("%s\n", strerror(5));
printf("%s\n", strerror(6));
printf("%s\n", strerror(7));
printf("%s\n", strerror(8));
return 0;
}
(2)简单应用
cpp
#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<errno.h>
int main()
{
//打开文件的函数为fopen()
//"r"表示以读的形式打开
//返回的是FILE型的指针，如果打开失败会返回空指针(NULL)
FILE* pf = fopen("text.txt","r");
//若打开的文件在程序路径下，可以使用相对路径(文件名)
fopen("C:\\Users\\admin\\Desktop\\text2.text","r");
//在其他位置要使用绝对路径，单个'\'会被识别为转义字符，所以要再加一个'\'
//打开文件失败后,fopen函数会将错误码存储在errno中
//errno---C语言设置的一个全局的错误码存储变量
//只要发生错误，都会把错误码存在errno中---始终记录最新的错误码
//调用errno需要应用头文件<errno.h>
if (pf == NULL)
{
printf("%s", strerror(errno));
}
return 0;
}六.字符分类函数 ------头文件<ctype.h>
重点：应用
举例：isspace()------判断空白字符
cpp
#include<stdio.h>
#include<string.h>
#include<ctype.h>
int main()
{
printf("%d\n", isspace('x'));
printf("%d\n", isspace(' '));
return 0;
}
1、iscntrl()------判断是否是控制字符(任何控制字符)
功能
判断是否是控制字符(任何控制字符)
返回值
若返回值为非0数字，则为控制字符，若返回0，则不是控制字符。
2、isspace()------判断是否是空白字符
功能：
判断是否是空白字符(空格、换页/f、换行\n，回车\r，制表符\t或者垂直制表符\v)
返回值：
若返回值为非0数字，则为空白字符，若返回0，则不是空白字符。
3、isdigit()------判断是否是十进制数字字符
功能：
判断是否是十进制数字字符(0-9)
返回值：
若返回值为非0数字，则为十进制数字字符，若返回0，则不是十进制数字字符。
4、isxdigit()------判断是否是十六进制数字字符
功能：
判断是否是十六进制数字字符(包括所有十进制数字，小写字母a-f，大写字母A-F)
返回值：
若返回值为非0数字，则为十六进制字符，若返回0，则不是控制字符。
5、islower()------判断是否是小写字母
功能：
判断是否是小写字母(a-z)
返回值：
若返回值为非0数字，则为小写字母字符，若返回0，则不是小写字母字符
6、isupper()------判断是否是大写字母
功能：
判断是否是大写字母(A-Z)
返回值：
若返回值为非0数字，则为大写字母字符，若返回0，则不是大写字母字符。
7、isalpha()------判断是否是字母字符
功能：
判断是否是字母字符(a-z或A-Z)
返回值：
返回值为非0数字则为控制字符，返回0则不是控制字符。
8、isalnum()------判断是否是字母字符或者数字字符
功能：
判断是否是字母字符或者数字字符(a-z、A-Z、0-9)
返回值：
若返回值为非0数字，则为字母字符或数字字符，若返回0，则不是字母字符或数字字符。
9、ispunct()------判断是否是标点符号字符
功能：
判断是否是标点符号字符(任何不属于数字或字母的图形字符)
返回值：
若返回值为非0数字，则为标点符号，若返回0，则不是标点符号。
10、isgraph()------判断是否是图形字符
功能：
判断是否是图形字符(任何图形字符)
返回值：
若返回值为非0数字，则为图形字符，若返回0，则不是图形字符。
11、isprint()------判断是否是可打印字符
功能：
判断是否是可打印字符(包括图形字符和空白字符)
返回值：
若返回值为非0数字，则为可打印字符，若返回0，则不是可打印字符。
七.字符转换函数
1.tolower(int c) ------字符转小写
cpp
#include<stdio.h>
#include<string.h>
#include<ctype.h>
int main()
{
printf("%c\n",tolower('H'));
return 0;
2.toupper(int c) ------字符转大写
cpp
#include<stdio.h>
#include<string.h>
#include<ctype.h>
int main()
{
printf("%c\n",toupper('h'));
return 0;