关于程序员:掌握字符与字符串C语言中的神奇函数解析一

✨✨ 欢送大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C 语言学习
贝蒂的主页：Betty‘s blog

咱们在学习 C 语言的过程中，除了应用最多的头文件 <stdio.h>，还会应用其余头文件，利用其中的库函数帮忙咱们简化代码的过程，比方像 <math.h>，<string.h> 等头文件，而明天贝蒂就带大家具体理解一下 <string.h> 吧。

<string.h> 中有很多实用的库函数，大抵分为两类：一类是像 strlen()，strchr()等作用于字符或字符串的字符函数和字符串函数，明天就让咱们先来介绍字符函数和字符串函数吧

1. 申明：size_t strlen(const char *str)

str — 要计算长度的字符串。

2. 作用：计算字符串 str 的长度，直到空完结字符(‘\0’)，但不包含空完结字符。

3. 返回值：该函数返回字符串的长度

strlen()函数的用法很简略，贝蒂来简略介绍一下吧~

#include<stdio.h>
#include<string.h>
int main()
{char arr[] = "abcdef";
    int len = strlen(arr);// 计算 arr 字符串的长度
    printf("%d\n", len);
    return 0;
}

输入后果：6

咱们曾经晓得了 strlen()函数的用法，那咱们可不可以自我实现一个 my_strlen()函数来模仿 strlen()函数的性能，当然是能够的呀，上面贝蒂将介绍三种实现办法。

思路：咱们能够用一个指针变量 p 指向首元素和一个计数变量 count 并初始化为 0，而后循环解援用指针所指向的元素，判断这个元素是否为‘\0’，不是每次 p ++，count++，是就跳出循环，返回 count。

代码实现如下：

#include<stdio.h>
int my_strlen(char* p)
{
    int  count = 0;
    while (*p)// 当指向 '\0'，也就是 0，为假跳出循环
    {
        p++;// 指向下一个元素
        count++;// 计数
    }
    return count;
}
int main()
{char arr[] = "abcdef";
    int len = my_strlen(arr);// 计算 arr 字符串的长度
    printf("%d\n", len);
    return 0;
}

思路：假如咱们要计算字符串“abcdef”的长度，咱们能够拆分为 1 +“bcdef”的长度，同理“bcdef”的长度能够拆分为 1 +“cdef”的长度 …… 了解了这个思路，咱们就能够实现递归，首先定义一个指针变量 p，如果p！=’\0’，咱们就把 p + 1 作为参数调用本函数，直到 p 为 0.

代码实现如下：

int my_strlen(char* p)
{if (*p != '\0')
    {return 1 + my_strlen(p + 1);// 每次调用 p + 1 指向下一个元素
    }
    else
    {return 0;// 完结递归}
}
int main()
{char arr[] = "abcdef";
    int len = my_strlen(arr);// 计算 arr 字符串的长度
    printf("%d\n", len);
    return 0;

首先大家要分明 指针 - 指针是指在同一空间内，两个指针之间的元素个数。

思路：首先定义两个指针 p1，p2，让两个指针指向首元素，而后让一个指针 p2 循环 ++，直到指向‘\0’就进行，最初返回 p2-p1。

代码实现如下：

int my_strlen(char* p1)
{
    char* p2 = p1;// 使两个指针都指向首元素
    while (*p2)
    {p2++;}
    return p2 - p1;// 返回两指针间接的元素的个数就是其长度
}
int main()
{char arr[] = "abcdef";
    int len = my_strlen(arr);// 计算 arr 字符串的长度
    printf("%d\n", len);
    return 0;
}

sizeof() 和 strlen() 的次要区别在于：

sizeof()是一个运算符，而 strlen() 是一个函数。

sizeof() 计算的是变量或类型所占用的内存字节数，而 strlen() 计算的是字符串中字符的个数。

sizeof() 能够用于任何类型的数据，而 strlen() 只能用于以空字符 ‘\0’ 结尾的字符串。

sizeof() 计算字符串的长度，蕴含开端的 ‘\0’，strlen() 计算字符串的长度，不蕴含字符串开端的 ‘\0’。

sizeof 和 strlen() 别离是 C 语言中两个十分罕用的关键字和函数，它们都与计算内存大小无关，然而它们的作用是不同的哦，大家肯定要辨别分明

1. 申明：int strcmp(const char str1,const charstr2)

str1 — 要进行比拟的第一个字符串。

str2 — 要进行比拟的第二个字符串。

2. 作用：strcmp() 会依据 ASCII 编码顺次比拟 str1 和 str2 的每一个字符，直到呈现不到的字符，或者达到字符串开端（遇见‘\0’）

3. 返回值：

如果返回值小于 0，则示意 str1 小于 str2。

如果返回值大于 0，则示意 str1 大于 str2。

如果返回值等于 0，则示意 str1 等于 str2。

strcmp 用于比拟字符串，并返回 >0，==0，<0 的值，让咱们看看他的具体应用吧

#include<stdio.h>
#include<string.h>
int main()
{char str1[] = "abcd";
    char str2[] = "Abcd";
    char str3[] = "abcd";
    char str4[] = "bbcd";
    int ret1 = strcmp(str1, str2);// 比拟 str1 与 str2
    int ret2 = strcmp(str1, str3);// 比拟 str1 与 str3
    int ret3 = strcmp(str1, str4);// 比拟 str1 与 str4
    printf("%d %d %d\n", ret1, ret2, ret3);
    return 0;    
}

输入：1 0 -1

strcmp()首先会比拟第一个字母的 ASCII 值，如果 == 则比拟第二个字符，直到遇见 ’\0′, 若不相等，则返回两个字符之差”

思路：首先两个字符串不能扭转，且不能传的参数不能为空指针，输出空指针让编译器报错，而后从第一个字符开始比拟，直到两个字符不相等（返回两个字符之差），如果在不相等之前曾经指向‘\0’, 间接返回 0.

代码实现如下：

#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
// 经 const 润饰让 *str1 与 *str2 无奈扭转
{assert(str1 && str2);// 判断 str1 和 str2 是否为空指针
    // 空指针间接报错，头文件 <assert.h>
    while (*str1== *str2)
    {if (*str1 == '\0')
        {return 0;}
        str1++;
        str2++;
    }
    return *str1 - *str2;
}
int main()
{char str1[] = "abcd";
    char str2[] = "Abcd";
    int ret = my_strcmp(str1, str2);
    printf("%d\n", ret);
    return 0;
}

申明：char strcpy(char dest, const char *src)，dest — 指向用于存储复制内容的指标数组，src — 要复制的字符串。

作用：把 src 所指向的字符串复制到 dest。须要留神的是如果指标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的状况。

返回值：该函数返回一个指向最终的指标字符串 dest 的指针。

#include <stdio.h>
#include <string.h>
int main()
{char src[40];
    char dest[40];
    strcpy(src, "im not betty");
    strcpy(dest, src);
    printf("最终的指标字符串：%s\n", dest);
    return 0;
}

输入后果：最终的指标字符串：im not betty

思路：咱们想要将 src 的内容拷贝进 des 中，首先 src 的内容不能被扭转，且保障都不是空指针，而后循环将 src 的内容赋值给 des，直到赋值完‘\0’，条件为假，跳出循环。

代码实现：

#include<assert.h>
char* my_strcpy(char* des, const char* src)// 避免 src 的内容被扭转
{assert(des && src);// 避免 des 与 src 是空指针
    char* ret = des;// 作为返回值
    while (*des++ = *src++)// 循环拷贝，当拷贝完 '\0'，判断为假，跳出循环
    {;}
    return ret;
}
int main()
{char src[40] = "abcdef";
    char des[40];
    my_strcpy(des, src);// 将 src 的内容拷贝去 des
    printf("%s\n", des);
    return 0;
}

申明：char strcat(char dest, const char *src)

dest — 指向指标数组，该数组蕴含了一个 C 字符串，且足够包容追加后的字符串。

src — 指向要追加的字符串，该字符串不会笼罩指标字符串。

作用：把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。

返回值：该函数返回一个指向最终的指标字符串 dest 的指针。

#include <stdio.h>
#include <string.h>
int main()
{char src[50];
    char dest[50];
    strcpy(src, "world!");
    strcpy(dest, "hello");
    strcat(dest, src);
    printf("最终的指标字符串：%s", dest);
    return 0;
}

输入后果：最终的指标字符串：hello world!

因为 strcat()函数的实现机制，所以 strcat()无奈对本人追加（会呈现死循环），如果要实现本人对本人的追加能够应用 strncat()函数，这个前面贝蒂会为大家解说

思路：实现 strcat 的办法其实和实现 strcpy 的办法相似，都是替换，只是要让 dest 先指向开端 ’\0’。

代码实现：

char* my_strcat(char* dest, const char* src)// 避免 src 的值被扭转
{assert(dest && src);// 不能为空指针
    char* ret = dest;
    while (*dest)// 使 dest 指向开端
    {dest++;}
    while (*dest++ = *src++)// 循环赋值
    {;}
    return ret;
}
int main()
{char dest[20] = "hello";
    char src[20] = "world!";
    my_strcat(dest, src);
    printf("%s", dest);
    return 0;
}

申明：char strchr(const char str, int c)

str — 要查找的字符串。

c — 要查找的字符。

作用：在参数 str 所指向的字符串中搜寻第一次呈现字符 c（一个无符号字符）的地位。

返回值：如果在字符串 str 中找到字符 c，则函数返回指向该字符的指针，如果未找到该字符则返回 NULL。

#include<string.h>
int main()
{char arr[20] = "hello betty";
    char* p = strchr(arr,'y');
    if (*p == NULL)
    {printf("没找到 \n");
    }
    else
    {printf("找到了 \n");
    }
    return 0;
}

思路：一样先排查空指针，而后循环寻找，如果寻找到，间接返回其地址。找不到就返回空指针 NULL

代码实现：

char* my_strchr(const char* str, int c)
{assert(str);// 排查空指针
    while (*str)
    {if (*str == c)
        {return str;// 找到返回其地址}
        str++;
    }
    return NULL;// 找不到返回空指针
}
int main()
{char arr[20] = "hello betty";
    char* p =my_strchr(arr,'y');
    if (*p == NULL)
    {printf("没找到 \n");
    }
    else
    {printf("找到了 \n");
    }
    return 0;
}

申明：char strstr(const char haystack, const char *needle)

haystack — 要被检索的 C 字符串。

needle — 在 haystack 字符串内要搜寻的小字符串。

作用：在字符串 haystack 中查找第一次呈现字符串 needle 的地位，不蕴含终止符 ‘\0’。

返回值：该函数返回在 haystack 中第一次呈现 needle 字符串的地位，如果未找到则返回空指针(NULL）

#include <stdio.h>
#include <string.h>
int main()
{char haystack[20] = "hello betty";
    char needle[10] = "betty";
    char* ret = strstr(haystack, needle);
    if (ret == NULL)
    {printf("未找到 \n");
    }
    else
    {printf("找到啦，子字符串是：%s\n", ret);
    }
    return 0;
}

输入后果：找到啦，子字符串是：betty

思路：首先用是用 s1,s2 指向两个字符串的首元素，用 p 记录 str1 中开始比拟的元素的地位，不便从新开始比拟。而后循环比拟，如果 *s1!=*s2，或者遇见‘\0’，就跳出循环，判断，如果是 s2 为‘\0’, 阐明配对胜利，s1 为‘\0’，则阐明后续长度不够，匹配失败啦，除开以上状况，就让 p ++，反复上述流程，直到 *p==‘\0’

状况 1：在 acbcef 中查找 acb

代码实现如下：

#include <stdio.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 (char*)p;// p 本来被 const 润饰
 
        }
        else if (*s1 == '\0' && s2 != '\0')//s1 后续字符少于 s2
        {return NULL;}
        p++;// 记录下一个地位
    }
    return NULL;
}
int main()
{char haystack[20] = "hello betty";
    char needle[10] = "betty";
    char* ret =my_strstr(haystack, needle);
    if (ret == NULL)
    {printf("未找到 \n");
    }
    else
    {printf("找到啦，子字符串是：%s\n", ret);
    }
    return 0;
}

关于程序员:掌握字符与字符串C语言中的神奇函数解析一

引言

1. 简介

2.strlen()函数

2.1 用法

2.2 实例

2.3 实现 strlen()

（1）计数法

（2）递归法

（3）指针 - 指针

2.4 sizeof 和 strlen()的区别

3. strcmp()函数

3.1 用法

3.2 实例

3.3 实现 strcmp()

4. strcpy()函数

4.1 用法

4.2 实例

4.3 实现 strcpy()

5.strcat()函数

5.1 用法

5.2 实例

5.3 实现 strcat()

6. strchr()函数

6.1 用法

6.2 实例

6.3 实现 strchr()

7. strstr()函数

7.1 用法

7.2 实例

7.3 实现 strstr()