目录
1.字符分类函数
C语言中有一系列的函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的，而这些函数的使用的需要包含一个头文件<ctype.h>
这些函数的使用方法非常类似，就拿islower函数来举例
int islower(int c);islower是用来判断参数部分的c是否是小写字母的
如果返回值是小写字母就返回非0的整数，如果不是就返回0
#include<stdio.h>
#include<ctype.h>
int main()
{
char arr[] = "Hello WErd";
int i = 0;
while (arr[i]!='\0')
{
if (islower(arr[i]))
{
arr[i] -= 32;
}
i++;
}
printf("%s\n", arr);
return 0;
}这段代码用来进行小写转大写，如果要大写转小写只需把-32改为+32
2.字符转换函数
c语言中提供了2个字符转换函数:
//将参数传进去的大写字母转小写字母
int tolower(int c);
//将参数传进去的小写字母转大写字母
int toupper(int c);tolower:大转小 | toupper:小转大，这两个函数是直接进行转换的
int main()
{
char arr[] = "Hello WErd";
int i = 0;
while (arr[i] != '\0')
{
if (islower(arr[i]))
{
//大写转小写
arr[i] = tolower(arr[i]);
//小写转大写
//arr[i] = toupper(arr[i]);
}
i++;
}
printf("%s\n", arr);
return 0;
}
3. strlen
strlen文档链接：
cplusplus.com/reference/cstring/strlen/?kw=strlen
https://cplusplus.com/reference/cstring/strlen/?kw=strlenstrlen：求取\0之前的字符串长度
1.字符串以\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包 含'\0')
2.参数指向的字符串必须要以 '\0' 结束
3.strlen函数的返回值为size_t，是无符号的，并且很容易出错
#include<stdio.h>
#include<string.h>
int main()
{
const char* str1 = "abcdef";
const char* str2 = "bbb";
// size_t size_t
// 3 - 6
if (strlen(str2) - strlen(str1) > 0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}
上面这段代码的答案并不是”<=“，而是”>“，因为strlen的返回值是size_t，size_t是无符号，一个无符号的值减去另一个无符号的值的结果也为无符号的值
if ((int)strlen(str2) - (int)strlen(str1) > 0)但是给其强制转换一下类型就可以正常加减
三种模拟实现
1.计数器实现
int my_strlen(const char * str)
{
int count = 0;
assert(str);
while (*str)
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "abcdefg";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}2.递归实现
不创建临时变量计数器
int my_strlen(const char* str)
{
assert(str);
//判断*str是否为\0，如果是就停止，如果不是就继续++
if (*str == '\0')
return 0;
else
return 1+strlen(str+1);//str+1是下一个字符的地址
}
int main()
{
char arr[] = "abcdefg";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}3.指针- 指针实现
int my_strlen( char* str)
{
assert(str);
char* p = str;
while (*p!='\0')
{
p++;
}
return p - str;
}
int main()
{
char arr[] = "abcdefg";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}4.长度不受限制的字符串函数
4.1 strcpy
strcpy文档链接：
strcpy - C++ Reference
strcpy:把源头的数据拷贝到目的地的空间去 dest :目的地 | source :源头
1.源字符串必须以 '\0' 结束
2.strcpy会将源字符串中的 '\0' 也拷贝到目标空间
3.目标空间必须足够大，以确保能存放源字符串
4.目标空间必须可以修改
int main()
{
char arr1[] = "hello word";
char arr2[20] = { 0 };
strcpy(arr2, arr1);
printf("%s\n", arr2);//（dest,source）
return 0;
}
模拟实现：
初始版本
void my_strcpy(char* dest,const char* src)
{
assert(src!=NULL);
assert(dest!=NULL);
//拷贝\0之前的内容
while(src!=\0)
{
*dest=*src;
dest++;
src++;
}
//拷贝\0
*dest=*src;
}
int main()
{
char arr1[] = "hello word";
char arr2[20] = { 0 };
my_strcpy(arr2, arr1);
printf("%s\n", arr2);//（dest,source）
return 0;
}优化版本
void my_strcpy(char* dest,const char* src)
{
assert(src!=NULL);
assert(dest!=NULL);
char* ret = dest;
//拷贝\0之前的内容
while(*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "hello word";
char arr2[20] = { 0 };
char* ret=my_strcpy(arr2, arr1);
printf("%s\n", arr2);//（dest,source）
return 0;
}4.2 strcat
strcat文档链接：
strcat - C++ Reference
strcat:追加一个source指向的字符串到目标空间（dest）里去
1.源字符串必须以 '\0' 结束
2.目标字符串在必须也得有\0，否则没办法知道从哪里开始追加
3.目标空间必须有足够的大，能容纳下源字符串的内容
4.目标空间必须可修改
int main()
{
char arr1[20] = "hello";
char arr2[] = "word";
strcat("%s\n", arr1, arr2);
printf("%s\n", arr1);
return 0;
}步骤：找到目标空间的\0，然后再拷贝数据
模拟实现：
函数返回的是目标空间的起始地址，返回类型为char*
char* my_strcat(char* dest, char* src)
{
assert(dest && src);
char* ret = dest;
//找到起始空间的\0
while (dest != '\0')
dest++;
//拷贝
while (*dest++ = *src++)
;//;号是一个空语句
return ret;
}
int main()
{
char arr1[20] = "hello";
char arr2[] = "word";
//模拟
my_strcat("%s\n", arr1, arr2);
printf("%s\n", arr1);
//使用
//char* s = my_strcat("%s\n", arr1, arr2);
//printf("%s\n",s);
return 0;
}一个问题：如果一个字符串自己给自己追加如何呢？答案是会越界访问并且会死循环
4.3 strcmp
strcmp文档链接：
strcmp - C++ Reference
strcmp:用来对两个字符串进行比较大小 返回值为int 类型
1.当第一个字符串大于第二个字符串的时候则返回>0的值
2.当第一个字符串等于第二个字符串的时候则返回0的值
3.当第一个字符串小于第二个字符串的时候则返回<0的值
判断两个字符串是对比两个字符串的字符的大小用ASCII值大小来比较
模拟实现：
int* my_strcmp(const char* str1, const char* str2)
{
int ret = 0;
assert(*str1 && *str2);
while (*str1==*str2)
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2++;
}
//1.
/*if (*str1 >*str2 )
{
return 1;
}
else
{
return -1;
}*/
//2.
return *str1 - *str2;
}
int main()
{
char arr1[20] = "abcd";
char arr2[20] = "abdhtf";
int ret = my_strcmp(arr1, arr2);
return 0;
}
str1 和 str2分别逐个向后一个一个比较，直到遇到第一个大小不同的字符，立马停下，后面都不比较了，无论这个字符串多长，都只看第一个遇到的不同的字符谁大谁小，以ASC|| 的差值作返回值
5. 长度受限制的字符串函数
5.1 strncpy
strncpy文档链接：
strncpy - C++ Reference
与strcpy相比，strncpy的参数多了一个num num：从source中最多拷贝几个字符
拷贝num个字符从源字符串到目标空间
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个
int main()
{
char arr1[20] = "abcd";
char arr2[20] = "xxxxxxxxxxxxxxxx";
int ret = strncpy(arr2, arr1,3);
//如果拷贝source的的字符串小于指定拷贝的num，那么后面就补\0
//int ret = strncpy(arr2, arr1,8);
printf("%s\n",arr2);
return 0;
}
5.2 strncat
strncat的文档链接：
strncat - C++ Reference
与strcat相比，strncat的参数多了一个num num：从source中最多追加几个
将source指向字符串的前num个字符追加到dest指向的字符串未尾，再追加一个\0字符
如果source指向的字符串的长度小于num的时候，只会将字符串中\0的内容追加到dest指向的字符串末尾
如果中间插入一个\0的话，就会从第一个\0开始追加
int main()
{
char arr1[20] = "abcd";
char arr2[20] = "xx\0xxxxxxxxxxxxxx";
strncat(arr2, arr1,3);
printf("%s\n",arr2);
return 0;
}5.3 strncmp
strncmp的文档链接：
strncmp - C++ Reference
与strcmp相比，strncmp的参数多了一个num num：从source中最多比较几个
比较str1和str2的前num个字符，如果相等就继续往后比较，最多比较num个字母，如果提前发现不⼀样，就提前结束，大的字符所在的字符串大于另外⼀个。如果num个字符都相等，就是相等返回0
当第一个字符串大于第二个字符串的时候则返回>0的值
当第一个字符串等于第二个字符串的时候则返回0的值
当第一个字符串小于第二个字符串的时候则返回<0的值
对比两个字符串的字符的大小用ASCII值大小来比较
int main()
{
char arr1[20] = "abcd";
char arr2[20] = "abcfhy";
int ret = strncmp(arr1, arr2, 6);
printf("%d\n", ret);
return 0;
}
在c语言中， 长度不受限制的字符串函数相对来说是不安全的，长度受限制的字符串函数相对来说是安全的
6.字符串查找
6.1 strstr
strstr的文档链接：
strstr - C++ Reference
需要包含头文件 #include <string.h>
strstr：在一个字符串（str1）中查找另一个字符串 （str2）第一次出现的位置
函数返回字符串str2在字符串str1中第一次出现的位置，如果有多次出现的话那么就返回从第一次出现位置
字符串的比较匹配不包含\0，以\0作为结束标志
int main()
{
char arr1[] = "hello word";
const char arr2[] = "llo";
//或者这种：const char* p = "llo";
char* ret = strstr(arr1,arr2);
if (ret != NULL)
{
printf("%s\n", ret);
}
else
{
printf("找不到\n");
}
return 0;
} 
模拟实现：
1.
这种情况需要有一个指针变量来记录开始匹配的位置
2.
这种情况可能存在多次匹配 ，需要有2个指针变量来记录起始位置
3.
字符串找完了也没找到
char* my_strstr(const char* str1,const char* str2)
{
const char* s1 = NULL;
const char* s2 = NULL;
const char* cur = str1;
while (*cur)
{
s1 = cur;
s2 = str2;
while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
{
s1++;
s2++;
}
//如果*s2为\0，则说明子字符串已经全部匹配完成
if (*s2 == '\0')
{
return cur;
}
cur++;
}
//当*cur为\0时，则返回NULL
return NULL;
}
int main()
{
char arr1[] = "abcdefgbcdkhu";
const char arr2[] = "bcd";
char* ret = my_strstr(arr1,arr2);
if (ret != NULL)
{
printf("%s\n", ret);
}
else
{
printf("找不到\n");
}
return 0;
}6.2 strtok
strtok文档链接：
strtok - C++ Reference
strtok:用于将一个字符串按照指定的分隔符进行分割，从而得到想要的子字符串
1.sep参数是个字符串，定义了用作分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
3.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以被strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改）
4.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
5.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
6.如果字符串中不存在更多的标记，则返回 NULL 指针
#include<stdio.h>
#include<string.h>
int main()
{
char str[] = "kiana@sjjwdjtmkadqyn.bh3"; //指定字符串
char arr[30];
strcpy(arr, str); //拷贝一份临时的指定字符串,以避免改变str
char* p = "@."; //指定的分隔符(标记)
char* tmp = strtok(arr, p); //使用一次strtok,因其返回的是一个指针,所以用字符指针接收
printf("%s\n", tmp); //会打印出什么呢?
return 0;
}
打印结果为：
kiana因为strtok函数找到str中的下一个标记，并将该标记用
\0结尾，然后返回一个指向该标记的指针
#include <stdio.h>
int main()
{
char *p = "kiana@sjjwdjtmkadqyn.bh3";
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);
}
}其中分隔符' . '和' @ '不需要注重顺序，但是要写齐
感谢观看~
kiana
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
