目录
strlen()函数（求字符串长度函数）
strlen()函数简介
1.字符串以'\0'为结束标志，从给定的地址向后访问字符，strlen()函数返回的是字符串中'\0'前面出现字符的个数；
# include <string.h>
int main()
{
char arr[] = "abcdef";
int len = strlen(arr);
printf("%d\n", len);
return 0;
}
运行结果：
字符数组arr存放的元素 'a', 'b', 'c', 'd', 'e', 'f', '\0',所以结果为6.
2. 参数指向的字符必须以'\0'结束，因为如果不以'\0'作为结束标志，则strlen()函数所求的长度为随机值；
# include <string.h>
int main()
{
char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
int len = strlen(arr);
printf("%d\n", len);
return 0;
}
运行结果：
这个结果是随机值，会从给定位置arr向后一直查找'\0',直到查找到'\0'为止；
3.strlen()函数的返回值为size_t，为无符号整型；
int main()
{
const char* p1 = "abcdef";
//strlen(p1)=6;
const char* p2 = "xxx";
//strlen(p2)=3
//由于strlen()函数的返回值为unsigned int
// unsigned int A=3 unsigned int B=6
//A-B进行的是A的补码+(-B)的补码，最后以无符号整型输出，所以p2>p1;
if (strlen(p2) - strlen(p1) > 0)
{
printf("p2>p1\n");
}
else
printf("p1>p2\n");
return 0;
}运行结果：
strlen()函数的模拟实现
assert() 头文件 # include<assert.h>
1.assert是宏，不是函数;
void assert(int expression)
2.如果expression结果为假即为0,断言失败，assert()会向标准输出装备输出一条错误消息，并调用abort()函数终止程序运行
3.如果expression表达式为真，断言成功，assert()不进行任何操作
assert()使用的注意事项:
每次断言只能检验一个条件，因为同时检查多个条件时，如果断言失败，无法直观判断是哪个条件失败;
计数器方式实现strlen()函数
# include <assert.h>
int my_strlen(const char* str)
{
assert(str != NULL);
int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}递归的方式实现strlen()函数
int my_strlen(const char* str)
{
assert(str != NULL);
if (*str == '\0')
{
return 0;
}
else
return 1 + my_strlen(str + 1);
}指针-指针的方式实现strlen()函数
指针-指针的前提两个指针指向同一块内存空间
数组是在内存空间连续存放的，并且随着下标的增大地址从低到高变化;
因为指针-指针的绝对值是中间元素的个数，只需指向'\0'处的指针-指向数组首元素的指针便可得到;
int my_strlen(const char* str)
{
assert(str != NULL);
char* p = str;//p记录起始位置的地址
while (*str != '\0')
{
str++;
}
return str - p;
}strcpy()函数（字符串拷贝函数）
函数简介
1. strcpy()函数会将字符指针source所指向的字符串（包括终止字符'\0'）复制到字符指针
destination所指向的字符串;
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abc";
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}运算结果：
2. 原字符串必须以'\0'结束，如果不以'\0'结束，会导致程序崩溃;
int main()
{
char arr1[] = "abcdef";
char arr2[] = { 'a', 'b', 'c' };
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}运行结果：
3. 会将源字符串的 '\0'拷贝到目标空间；
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abc";
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
4.目标空间必须足够大，确保能存放源字符串；如果目标空间不够大，导致程序崩溃;
int main()
{
char arr1[] = "xx";
char arr2[] = "abcdef";
strcpy(arr1, arr2);
return 0;
}运行结果:
5. 目标空间必须可变；
int main()
{
//常量字符串不允许被修改，目标空间不可变，程序崩溃
char*p = "abcdef";
char arr[] = "abc";
strcpy(p, arr);
printf("%s\n", p);
return 0;
}运行结果：
6.strcpy()函数的返回值为目标空间的起始地址；strcpy()函数的返回类型设置为了实现链式访问；
strcpy()函数的模拟实现
strcpy()函数实现方式1
char* my_strcpy(char*dest,const char* src)
{
assert(dest != NULL);
assert(src != NULL);
char* ret = dest;//记录目标空间的起始位置
while (*src != '\0')
{
*dest = *src;
dest++;
src++;
}
//'\0'的拷贝
*dest = *src;
return ret;
}strcpy()函数实现方式2
char* my_strcpy(char*dest, const char* src)
{
assert(dest != NULL);
assert(src != NULL);
char* ret = dest;//记录目标空间的起始位置
while (*dest++ = *src++)
{
;
}
return ret;
}strcat()函数（字符串追加函数）
函数简介
1. strcat()函数会将字符指针source所指向的字符串追加到字符指针destination所指向的字符串后面，并用 '\0' 终止字符串; 字符指针source所指向的字符串的初始字符覆盖字符指针destination所指向的字符串的'\0';
int main()
{
char arr1[20] = "hello";
char arr2[] = " world";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}运行结果：
2. 源字符串必须以'\0'结束；
3.会将源字符串'\0'拷贝到目标空间；
int main()
{
char arr1[20] = "hello\0xxxxxxxx";
char arr2[] = " world";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
4. 目标空间必须足够大，目标空间必须可变；
5. 原则上不允许字符串自己给自己追加，因为会覆盖掉'\0',从而进入死循环；
int main()
{
char arr[20] = "world";
strcat(arr, arr);
printf("%s\n", arr);
return 0;
}运行结果：
strcat()函数的模拟实现
实现思路：
1. 首先找到目标空间字符串中的 '\0'；
2. 然后把源字符串拷贝到目标空间；
char* my_strcat(char* dest, const char*src)
{
assert(dest != NULL);
assert(src != NULL);
//记录目标空间的起始地址
char* ret = dest;
//先找到目标空间中的 '\0'
while (*dest != '\0')
{
dest++;
}
//字符串拷贝
while (*dest++= *src++)
{
;
}
return ret;
}strcmp()函数（字符串比较大小函数）
函数简介
1. strcmp()函数根据ASCII编码开始比较俩个字符串中的第一对字符，如果彼此相等, 继续 比较下一对字符所对应的ASCII码值，直到字符不相同或者达到终止字符'\0';
2. 函数返回值类型为 int
3. 函数返回值为0，表示俩个字符串相等；
函数返回值为大于0的数字，表示第一个字符串大于第二个字符串；
函数返回值为小于0的数字，表示第一个字符串小于第二个字符串；
int main()
{
char* arr1 = "abcdef";
char* arr2 = "abc";
int ret = strcmp(arr1, arr2);
if (ret > 0)
{
printf("> ");
printf("ret=%d\n", ret);
}
else if (ret == 0)
{
printf("=");
printf("ret=%d\n", ret);
}
else
{
printf("<");
printf("ret=%d\n", ret);
}
return 0;
}运行结果
strcmp()函数的模拟实现
int my_strcmp(const char*s1, const char* s2)
{
assert(s1 != NULL);
assert(s2 != NULL);
while (*s1 == *s2)
{
if (*s1 == '\0')
{
return 0;
}
s1++;
s2++;
}
if (*s1 > *s2)
return 1;
else
return -1;
}strstr()函数（字符串查找函数）
函数简介
strstr()函数是在字符指针str1指向的字符串中查找是否含有字符指针str2所指向的字符串；
如果存在，返回str2所指向的字符串在str1指向的字符串中第一次出现的地址；
否则返回NULL；
int main()
{
char arr1[] = "abcdefcde";
char arr2[] = "cde";
char*ret=strstr(arr1, arr2);
if (ret == NULL)
{
printf("找不到子串\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}运行结果：
strstr()函数的模拟实现
情况1：
如果str1指向的字符和str2指向的字符不相等，则str1指向下一个字符，str2指针指向不变，循环往复，当str1指向'\0'时，得出str1所指向的字符串不含str2所指向的字符串，此时返回NULL; 如图
情况2：
当str1向后读取的过程中，发现两个指针指向的字符开始相等，str1继续向后读取字符，str2也向后读取字符，若str1所指向的字符和str2所指向的字符一直相等，直到str2指向 '\0', 此时可知str1所指向的字符串包含str2所指向的字符串；返回str2所指向的字符串在str1指向的字符串中第一次出现的地址；
情况3：
当str1向后读取的过程中，发现俩个指针指向的字符开始相等，str1继续向后读取字符，str2也向后读取字符，若str1所指向的字符和str2所指向的字符不全相等，此时str2需要返回到str2所指向字符串的首字符的地址，str1需要返回到第一次和str2所指向字符相等的后一个位置；
char* my_strstr(char* str1, char* str2)
{
assert(str1 != NULL);
assert(str2 != NULL);
//创建s1,s2向后查找字符，保留str1,str2是为了方便返回;
char* s1 = str1;
char* s2 = str2;
//需要一个指针记录str1中的字符串是从哪个位置开始匹配;
char* cur = str1;
while (*cur != 0)
{
s1 = cur;
//s2回到起始位置;
s2 = str2;
while ((*s1!='\0')&&(*s2!='\0')&&(*s1==*s2))
{
s1++;
s2++;
}
//子串中所有字符查找结束
if (*s2 == '\0')
{
return cur;
}
//发现*s1!=*s2,说明当前位置不可能匹配成功
//需要从下一个字符开始;
cur++;
//从cur++的位置跳转到s1=cur;的位置
//因为当前位置不可能匹配成功,s1也应该指向下一个位置;
}
return NULL;
}
3564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
