目录
0. 前言
1. 函数介绍
1.1 strlen
1.1.1主动改变'\0'的位置
✅"strlen函数的返回类型是size_t - 无符号整型"✅
当使用strlen函数但不引用头文件时,执行结果超出预料:
求字符串长度的方法
1.计数器
2.递归
3.指针 - 指针
1.2 strcpy
正常的普通操作
错误操作:
1.arr1数组名是一个地址,赋给一个地址arr2。
2.数组没有'\0'
3.错误示范 - 目标空间不够大
4.目标空间不能被修改
1.2.1学会strcpy模拟实现:
合2为1写法
1.3 strcat
1.3.1模拟实现strcat
返回值问题?
1.3.2strcat自己对自己追加
注意const char*src:
关于strcpy和strcat的区别:
1.4 strcmp
前提
举例:
1.4.1strmpy的模拟实现
函数实现部分也可以写成:
主函数部分也可以写成:
1.5 strncpy
1.6 strncat
1.6.1strncat的正常调用
1.6.2模拟实现strncat
编辑模拟实现strncat,自己追加自己的情况
关于everything:
1.7 strncmp
1.8 strstr
1.8.1strstr的模拟实现❗❗❗
前提准备:
一点小疑惑:❓
这篇文章是关于strlen,strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr的知识点总结,花了不少精力与时间,文章整体超过一万字,可以用来快速查找字符串函数的功能和实现
C 语言中对字符和字符串的处理很是频繁,但是 C 语言本身是没有字符串类型的,字符串通常放在常量字符串 中或者 字符数组 中。字符串常量 适用于那些对它不做修改的字符串函数
size_t strlen ( const char * str );
字符串末尾是隐藏着一个'\0'的
#include
#include
int main()
{
char arr1[] = "abcdef";
int len1 = strlen(arr1);
printf("%d\n", len1);
return 0;
}
#include
#include
int main()
{
char arr1[] = "abc\0def";
int len1 = strlen(arr1);
printf("%d\n", len1);
return 0;
}
不知道'\0'的位置
#include
#include
int main()
{
char arr2[3] = { 'a','b','c'};
int len2 = strlen(arr2);
printf("%d\n", len2);
return 0;
}
原因:
没有'\0',一直从'a'的位置往后数,内存里面一直往后找,什么时候找到'\0',什么时候停下,所以得出的结果是一个随机值
以下代码函数相减结果为-3,(因为无符号数减无符号数为无符号数),但是-3作为一个无符号整型来看待,那就是说内存中的补码直接当成了一个数字来看待了,而不是转换成原码来看待,那将是一个正整数
#include
int main()
{
if (strlen("abc") - strlen("abcdef") > 0)
{
printf(">\n");
}
else
{
printf("<=\n");
}
}
下面的出现现象是我发现的一些问题:
不引用头文件,但是使用它的库函数,这种行为,编译器连警告也没有,正常执行
#include
//#include
int main()
{
if (strlen("abc") - strlen("abcdef") > 0)
{
printf(">\n");
}
else
{
printf("<=\n");
}
}
个人反思:永远记住一个点,就是使用头文件,使用库函数的时候一定要包含正确的头文件,否则它可能会有一些异常的情况。
这就是一次异常啊,因为正常情况下:size_t 返回的值是unsigned int类型的,即使算出负数,它也是会转换成一个>=0的数字。
#include
#include
#include
int my_strlen(const char* str)
{
int count = 0;
assert(str);//断言一下是不是NULL指针
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "bit";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
题目要求:不创建临时变量,求字符串长度
思路:当第一个字符‘b’不为‘\0’,那整个字符串长度就是1+my_strlen(str+1)
要是第一个字符串(从str指向的首地址开始)为‘\0’,那就return 0
#include
int my_strlen(char *str)
{
if (*str != '\0')
return 1 + my_strlen(1 + str);
else
return 0;
}
int main()
{
char arr[] = "bit";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
指针- 指针 == 地址 - 地址
前提:
- 两个指针指向同一块空间,指针的类型是一致的
- 指针 - 指针得到的是指针和指针之间的元素个数(这是语法规定的)
#include
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9};
int n = &arr[9] - &arr[0];
printf("%d\n", n);
return 0;
}
char* strcpy ( char * destination , const char * source );
1️⃣常量字符串:
char* p = "abcdefghi"
2️⃣字符串初始化数组本身:
char arr2[] = "hehe\n";
#include
#include
int main()
{
char arr1[] = "abcdef";
char arr2[] = { 0 };
strcpy(arr2, arr1);
printf("%s\n", arr2);
return 0;
}
#include
#include
int main(){
char arr1[] = "qwertyuiop";
char arr2[] = arr1;//err
char arr2[20] = { 0 };
arr2 = arr1;//err
return 0;
}
#include
#include
int main()
{
char arr1[3] = { 'a','b','c' };
char arr2[20] = "xxxxxxxx";
strcpy(arr2, arr1);
printf("%s\n", arr2);
return 0;
}
可以看到字符'c'后面还有其它不是数组的元素,那是因为'c'的后面没有'\0',所以它会从'c'的后面一直往后找‘\0’, 直到找到为止
#include
#include
int main(){
char arr1[20] = "abcdefgh";
char arr2[3] = "";//错误示范 - 目标空间必须足够大
strcpy(arr2,arr1);
printf("%s\n", arr2);
return 0;
}
#include
#include
int main()
{
char* p = "abcdefghi";
char arr2[] = "hehe\n";
strcpy(p, arr2);//这也是一样错的示范 - 目标空间必须可以修改
printf("%s\n", p);
return 0;
}
strcpy的模拟实现:函数返回类型是char*,把源头的数据拷贝到目标空间之后,整个目标空间发生变化,把目标空间的地址返回来。要感知函数的变化,返回目标空间的地址是比较合适的。
对于ret来说,返回的时候。arr2数组是一段连续的空间,所以返回首元素地址,后面就紧跟的是后序元素
#include
#include
char* my_strcpy(char* dest, const char* src)//加上const对源头的数据进行保护
{
char* ret = dest;
assert(dest && src);
while (*dest++ = *src++)
{
;
}
return ret;//数组是一段连续的空间,所以返回首元素地址,后面就紧跟的是后序元素
}
int main()
{
char arr1[] = "hehe";
char arr2[20] = { 0 };
my_strcpy(arr2, arr1);
printf("%s\n",arr2);
return 0;
}
char* my_strcpy(char* dest, const char* src)
{
char* ret = dest;
assert(dest && src);
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "hehe";
char arr2[20] = { 0 };
printf("%s\n", my_strcpy(arr2, arr1));//合2为1
return 0;
}
char * strcat ( char * destination , const char * source );
注意:拷贝(strcpy)的意思是覆盖掉,与追加不一样, strcat也就是追加的时候第一个字符是把'\0'给覆盖掉,之后在拷贝完后加上一个‘\0’即可。
#include
int main()
{
char arr1[20] = "hello \0xxxxxxxxxxx";
char arr2[] = "world";
strcat(arr1, arr2);//会以\0为起始位置拷贝
printf("%s\n", arr1);
}
模拟实现的图解:
#include
#include
char* my_strcat(char* dest, const 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[] = "world";
//追加
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
执行:
注意问题:
只是它的返回值这里没有使用到而已,库函数是有返回值的,因为有些场景下 ,我们需要用到字符串的首地址
可以理解为:我可以不用,但是应该有, 因为这是关于这个strcat的模拟实现,是对于它的库函数的一种理解,所以说它的库函数也可能会这样使用。
会陷入死循环, 这种情况是不能用strcat的,要用的是strncat!
#include
#include
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest != '\0')
{
dest++;
}
//拷贝
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "bit";
my_strcat(arr1, arr1);
printf("%s", arr1);
return 0;
}
图解:
不会通过src来改变里面空间的数据,但是把src指向的内容放进dest指向的空间里面去了
因为dest指针没有受到限制,是不能通过src来改变这块空间的数据,并不意味着这块空间不能被改变,数组内容还是可以被改变的.
src本身是改变了,是因为src的指向在发生变化,这块空间,是通过dest去改变的
这里比较的是2个字符串的内容的时候,不能使用 == ,应该使用strcmp;
char* p = "abcdef";//因为"abcdef"把这个表达式首字符'a'的地址给了p指针,所以这个表达式的值是'a'的地址
//这里下面比的其实是"abcdef"的'a'的地址和"bbcdef"的'b'的地址是否相等,并没有比较内容
if ("abcdef" == "bbcdef")//这里比较的是两个字符串首字符的地址,而不是字符串内容
{
}
:首先说明这个函数strcmp实现两个字符串的比较的时候是跟长度不存在对应的关系,并不是谁长谁就大!
int strcmp ( const char * str1, const char * str2 );
"abcdef"
"bbq"
这两个字符串,上面长,下面短,对应位置的字符比较,根据ascll码值,a是小于b,所以
bbq大于abcdef
总结:
当对应位置的字符比较时,,如果相等就跳过一个字符比较,当它们不相等时,ascll码值的大整个字符串就大,与长度无关
再举例:
"abcdef"
"abbbbbbbbb"
因为'c'的ascll码值大于'b',所以"abcdef"大
标准规定:
正常代码操作:
#include
#include
int main()
{
//跟长度没关系.
char arr1[] = "abcdef";
char arr2[] = "bbq";
int ret = strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
arr1
#include
int my_strcmp(const char* str1, const char* str2)
{
while (*str1 == *str2)
{
if(*str1=='\0')
return 0;
str1++;
str2++;
}
if (*str1 > *str2)
return 1;
else
return -1;
}
int main()
{
char arr1[] = "abzqb";
char arr2[] = "abq";
int ret = my_strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
写成(const char* str1, const char* str2)的原因:
str1和str2不会去修改原字符串的内容,只是比较它们的大小,所以只要能拿到这个字符串内容就可以了。
#include
int my_strcmp(const char* str1, const char* str2)
{
while (*str1 == *str2)
{
if(*str1==*str2)
str1++;
str2++;
}
return *str1 - *str2;//ascllm码值相减}
int main()
{
char arr1[] = "abzqw";
char arr2[] = "abq";//这里不能写成 if (strcmp(arr1, arr2) == 1),vs这个环境底下大于返回1,其它的平台有可能返回其它大于0的数字,所以不能这样写
⬇⬇⬇
//要写成这样
if (strcmp(arr1, arr2) > 0)
printf(">\n");
else if (strcmp(arr1, arr2) == 0)
printf("=\n");
if (strcmp(arr1, arr2) <0)
printf("<\n");
return 0;
}
整体来说:
strcpy,strcat,strcmp这三种函数,是长度不受限制的字符串函数,以及scanf这些函数在vs等高版本系列的编译器看来都是不安全的,原因是:arr2太小放不下,程序崩溃
#include
int main()
{
char arr1[] = "abcdef";
char arr2[5] = { 0 };
strcpy(arr2, arr1);
printf("%s\n", arr2);
return 0;
}
所以为了解决这种不安全,引入了一系列的长度受限制的字符串函数strncpy,strncat,strncmp;
char * strncpy ( char * destination, const char * source, size_t num );
整体区别其实就比strcpy多了一个参数(size_t num)限制。
这里要注意的是,如果需要拷贝的个数大于整体的源字符串的大小,那么拷贝的时候不够就用'\0'或者0来补充
int main()
{
char arr1[] = "abcdef";
char arr2[20] = "xxxxx";
strncpy(arr2,arr1,20);
printf("%s\n", arr2);
return 0;
}
因为arr1(源字符串)整体大小是6+1=7(它包含的'\0'), 所以补的时候只需要补三个'\0'就行了
个人认为:
只需要看要拷贝的那个个数是多少,然后把源字符串加上'\0'的总体个数相减就行
也就是10-(6+1)=3,所以要补的'\0'个数就是 3个
char * strncat ( char * destination, const char * source, size_t num );
#include
#include
int main()
{
char arr1[20] = "hello \0xxxxxxxxxxxx";
char arr2[] = "abcdef";
strncat(arr1, arr2, 10);
printf("%s\n", arr1);
return 0;
}
可以看到拷贝前的状况:
拷贝之后:
这个函数的情况其实时,你让我追加几个就追加几个,追加完之后我就会在后面再补一个'\0',也不会多拷贝数据
总结:追加的时候源字符串只有7个字符(6+1),这里已经包括’\0’了,那就停止了,并不会多拷贝’\0'
记住拷贝完字符串在后面补一个'\0'即可。
#include
#include
int main() {
char arr1[20] = "hello \0xxxxxxxxxxxx";
char arr2[] = "abcdef";
int n = 0;
scanf("%d", &n);
char* p = arr1;
char* q = arr2;
assert(arr1);
assert(arr2);
while (*p)
{
p++;
}
while (n--) {
*p = *q;
p++;
q++;
}
*p = '\0';
printf("%s",arr1);
printf("\n");
}
关于strncat模拟实现不多说了,毕竟下面的自己追加自己的情况才是重点
#include
#include
int main() {
char arr1[20] = "hello \0xxxxxxxxxxxx";
int n = 0;
scanf("%d", &n);
char* p = arr1;
char* q = arr1;
assert(arr1);
while (*p)
{
p++;
}
while (n--) {
*p = *q;
p++;
q++;
}
*p = '\0';
printf("%s",arr1);
printf("\n");
}
图解:
上面的第一个图是p指针和q指针初始化的位置
第二个图它们的最终位置
个人理解:
到n--成0的时候,假设拷贝三次,到第三个字符的时候,q指针最终还是会走一下
因为这是模拟实现库函数,是方便理解库函数的实现逻辑的
也就是q指针的最终位置,所以说库函数也是这样,strncat,是会把q指针的最终位置改成'\0'的
提示打开,everything的时候可以观察到以上库函数的代码实现,但这不是源代码,是参考代码
int strncmp ( const char * str1 , const char * str2 , size_t num );
strncmp的正常操作
#include
int main()
{
char arr1[] = "abcdefadawdawfwa";
char arr2[] = "abcq";
int ret = strncmp(arr1, arr2, 8);
printf("%d\n", ret);
return 0;
}
个人理解:
如果n(要拷贝的个数)比str1或者str2其中一个要大,或者比两个都要大,那就找最短的字符串,比完就ok了
char * strstr ( const char *str1, const char * str2);
#include
int main()
{
char arr1[] = "abcdefgh";
char arr2[] = "de";
char* p = strstr(arr1, arr2);
if (p == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", p);
}
return 0;
}
找到了:
找不到:
str1和str2是用来记录初始位置的,而s1和s2是借助遍历字符串的
cp呢是匹配成功的时候返回匹配成功的字符串的指针。
总共就五个指针,只有三个是要用到的分别是s1,s2和cp。
#include
char* my_strstr(const char* str1, const char* str2)
{
char* s1 = NULL;
char* s2 = NULL;
char* cp = (char*)str1;//匹配成功的时候返回匹配成功的字符串的指针,跟下面的那个str2一样的情况
while (*cp)
{
s1 = cp;
s2 = (char*)str2;//编译器报警阿,把一个相对安全的指针交给一个不安全的指针,这个权限是放大了
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return cp;
}
cp++;
}
return NULL;
}
int main()
{
char arr1[] = "abcdebcdf";
char arr2[] = "bcd";
char* p = my_strstr(arr1, arr2);
if (p == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", p);
}
return 0;
}
执行:
图解:根据代码配合图理解即可。两图的指针指向情况均为它们的最终位置!
1.最基本的匹配情况:
2.上难度了
1.为什么不拿str1和str2走?
str1和str2是用来记住起始位置的,当两者走远的时候,想回到起始位置,就没有人知道起始位置在哪里了,就借助s1和s2来往后遍历字符即可
2.*s1存在的必要性,有必要吗?
有必要:
比如说
aabcdefgh和bcd
s1肯定是比s2指向的字符串长对不对,但是如果你手动去干预,aabc\0defghwhile(*s1)这个条件就有存在的必要,加上*s1 只是咱们更加严格一点
3.这个while(*cp)循环又是干啥的?
如果匹配成功 就直接返回cp了
但是如果没有 就要从str1后面一位继续开始匹配
简单来说:
如果匹配成功了,这个只用走一遍
进入循环,出去循环如果一次匹配失败
进入循环,再进入循环,再进入循环.........出去循环,直到匹配成功为止
接下来还有下半章的知识,欢迎各位大佬的指导和补充!