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

5次阅读

共计 5344 个字符，预计需要花费 14 分钟才能阅读完成。

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

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

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

申明：int strncmp(const char str1, const char str2, size_t n)

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

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

n — 要比拟的最大字符数。

作用：把 str1 和 str2 进行比拟，最多比拟前 n 个字符

返回值:

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

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

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

#include<stdio.h>
#include<string.h>
int main()
{char arr1[20] = "abcdef";
    char arr2[20] = "abcddd";
    int ret1 = strncmp(arr1, arr2, 3);// 比拟前三个字符
    int ret2 = strncmp(arr1, arr2, 8);// 即便给出的 num 太大，遇见 '\0' 也会进行
    int ret3 = strncmp(arr1, arr2, 6);// 比拟全副字符
    printf("%d %d %d\n", ret1, ret2,ret3);
    return 0;
}

输入后果：0 1 1

思路：总体思路与 strcmp() 的设计思路一样，只需退出限度比拟字符个数的条件即可~

代码实现：

#include <stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, size_t n)
{assert(str1 && str2);
    while (n-- && *str1 == *str2)// 任意一个条件不满足就跳出循环
    {if (*str1 =='\0')
        {return 0;}
        str1++;
        str2++;
    }
    return *str1 - *str2;
}

申明：char strncpy(char dest, const char *src, size_t n)

dest — 指向用于存储复制内容的指标数组。

src — 要复制的字符串。

n — 要从源中复制的字符数。

作用：把 src 所指向的字符串复制到 dest，最多复制 n 个字符。当 src 的长度小于 n 时，dest 的残余局部将用‘\0’填充。

当 src>= n 时：

#include <stdio.h>
#include <string.h>
int main()
{char src[40] = {0};
    char dest[12] = {0};
    strcpy(src, "This is runoob.com");
    strncpy(dest, src, 10);
    printf("最终的指标字符串：%s\n", dest);
    return 0;
}

输入后果：最终的指标字符串：This is ru

当 src<n 时

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

输入后果：最终的指标字符串：This

思路：总体实现思路和 strcpy() 差不多，然而要分 src<n 时，src>= n 两种状况探讨

char* my_strncpy(char* dest, const char* src, int n)
{assert(dest && src);
    char* ret = dest;    // 将 dest 首地址贮存在 ret 中, 不便返回
    while (*src && n)
    {
        *dest = *src;
        dest++;
        src++;
        n--;
    }
    if (n != 0)//n>src
    {while (n)
        {
            *dest = '\0';
            dest++;
            n--;
        }
    }
    
    return ret;  // 返回数组的首地址
}

申明：char strncat(char dest, const char *src, size_t n)

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

src — 要追加的字符串。

n — 要追加的最大字符数。

用法：把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。

如果 n <src 的长度，将 source 指向字符串的前 n 个字符追加到 dest 指向的字符串开端，再追加⼀个 \0 字符。

如果 n >=src, 只会将字符串中到 \0 的内容追加到 dest 指向的字符串开端

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

当 n <src 时：

#include<string.h>
int main()
{char str1[20];
    char str2[20];
    strcpy(str1, "hello");
    strcpy(str2, "helloworld");
    strncat(str1, str2, 6);
    printf("%s\n", str1);
    return 0;
}

输入后果：hello hellow

当 n >=src 时：

#include<string.h>
int main()
{char str1[20];
    char str2[20];
    strcpy(str1, "hello");
    strcpy(str2, "helloworld");
    strncat(str1, str2, 15);
    printf("%s\n", str1);
    return 0;
}

输入后果：hello helloworld

因为 strncat() 函数会主动在开端补充 ’\0‘的劣势，所以能够用于“本人对本人增加”

int main()
{char arr[10] = "abc";
    strncat(arr, arr, 3);
    printf("%s", arr);
    return 0;
}

思路：也和 strcat() 实现办法大致相同，然而要留神如果 n <src 时，要在开端主动补充 ’\0’ 哦

代码实现：

#include<assert.h>
char* my_strncat(char* dest, const char* src, int n)
{
    char* ret = dest;  // 将 dest 首地址贮存在 ret 中
    assert(dest&&src);  // 保障 dest、src 非空
    while (*dest != '\0')// 找到 dest 结尾的‘\0’{dest++;}
    while (n && (*dest++ = *src++))// 把 src 里的字符一个个放入 dest 后
    {n--;   // 循环跳出条件}
    if(n==0)
    {*dest = '\0'; // 如果 n <src}
    return ret; // 返回 dest 字符串起始地址
}

申明：char strtok(char str, const char *delim)

str — 要被分解成一组小字符串的字符串。第一次调用 strtok() 时，这个参数应该是你想要宰割的字符串。随后的调用应该将此参数设置为 NULL，以便持续从上次的地位宰割。

delim — 蕴含分隔符的 C 字符串。

作用：strtok() 用于将字符串宰割成一系列的子串

返回值：该函数返回被合成的第一个子字符串，如果没有可检索的字符串，则返回一个空指针。

#include <string.h>
#include <stdio.h>
int main() 
{char str[80] = "This is - betty -@class";
    const char s[] = "-@";
    char* p = strtok(str, s);// 第一次传参
    while (*p != NULL)
    {printf("%s\n", p);
        p = strtok(NULL, s);// 非第一次传参
    }
    return 0;
}

输入后果：

This is
betty
class

简略来说：“strtok() 就是把从指标字符串中，以分隔符为标记，将其分成若干个子串，并且须要屡次调用”

思路剖析：

第一步：

先判断是否为第一次传入

第二步：

宰割起始的宰割符，咱们先假如须要在“@+abc”中切割“@+”

首先断定 p1 中首元素是否须要切割（在 p2 中排查直到遇见‘\0’）。
如果匹配胜利，让 pp+ 1 指向下一个元素，让 p3 从新指向 p2 的首元素，持续排查下一个元素。
如果排查失败，p2 或 pp 指向‘\0’，如果 p2 指向 ’\0’，阐明起始地位的宰割符排查胜利，如果 pp 指向‘\0’，阐明没有再宰割的字符串，返回 NULL。

assert(p2);// 避免 p2 为空指针
static char* pp= NULL;//static 润饰，缩短其生命周期
// 让其第二次调用时后能指向下一个字符串
char* ret = NULL;// 作为返回值
char* p3 = (char*)p2;// 记录 p2 的初始地位
if (p1 != NULL)
{pp = p1;// 第一次传入}
while (*pp && *p2)// 排除起始的宰割符
{if (*p2 == *pp)
    {
        pp++;
        p2 = p3;// 胜利找到再从新匹配
    }
    else
    {p2++;// 匹配下一个字符}
}

第三步：

宰割后续字符串，咱们假如在“ab@cd”中宰割“@”。

ret = pp;// 记录初始地位，不便返回
p2 = p3;// 让 p2 指向初始地位
while (*pp && (*pp!= *p2++))// 开始匹配
{if (*p2=='\0')
    {
        pp++;// 判断下一个字符
        p2 = p3;// 让 p2 从新开始匹配
    }
}
if (*pp)// 判断是不是 '\0'
{*pp++ = '\0';// 宰割字符串，并指向下一个字符}
return ret;

第四步：

当非第一步传入时，*pp==‘\0’时，阐明宰割完结，返回 NULL.

if (p1 == NULL && pp=='\0')// 查找结束
{return NULL;// 最初返回空指针}

残缺代码：

#include <assert.h>
#include <stdio.h>
char* my_strtok(char* p1, const char* p2)
{assert(p2);// 避免 p2 为空指针
    static char* pp= NULL;//static 润饰，缩短其生命周期
    // 让其第二次调用时后能指向下一个字符串
    char* ret = NULL;// 作为返回值
    char* p3 = (char*)p2;// 记录 p2 的初始地位
    if (p1 == NULL && *pp=='\0')// 查找结束
    {return NULL;// 最初返回空指针}
    if (p1 != NULL)
    {pp = p1;// 第一次传入}
    while (*pp && *p2)// 排除起始的宰割符
    {if (*p2 == *pp)
        {
            pp++;
            p2 = p3;// 胜利找到再从新匹配
        }
        else
        {p2++;// 匹配下一个字符}
    }
    if (*pp = '\0')
    {return NULL;// 第一次排查指向 '\0'}
    ret = pp;// 记录初始地位，不便返回
    p2 = p3;// 让 p2 指向初始地位
    while (*pp && (*pp!= *p2++))// 开始匹配
    {if (*p2=='\0')
        {
            pp++;// 判断下一个字符
            p2 = p3;// 让 p2 从新开始匹配
        }
    }
    if (*pp)// 判断是不是 '\0'
    {*pp++ = '\0';// 宰割字符串，并指向下一个字符}
    return ret;
}

申明：char *strerror(int errnum)

errnum — 谬误号，通常是 errno。

作用：从外部数组中搜寻谬误号 errnum，并返回一个指向谬误音讯字符串的指针。strerror 生成的谬误字符串取决于开发平台和编译器。

返回值：该函数返回一个指向谬误字符串的指针，该谬误字符串形容了谬误 errnum。

#include<string.h>
#include<errno.h>// 错误码的头文件
int main()
{
    // 每一个错误码对应一个错误信息
    printf("%s\n", strerror(0));
    printf("%s\n", strerror(1));
    printf("%s\n", strerror(2));
    printf("%s\n", strerror(3));
    return 0;
}

输入：

No error（没有谬误）
Operation not permitted（操作不容许）
No such file or directory（没有这样的文件）
No such process（没有这样的过程）

strerror 经常用于动态内存开拓和文件的操作

FILE* pfwrite = fopen("contact.txt", "wb");
if (pfwrite == NULL)
{printf("%s\n", strerror(errno));// 如果关上失败，输入错误信息
    return 1;
}
pc->data = (peoinfo*)calloc(3 , sizeof(peoinfo));
if (pc->data == NULL)
{printf("inticontact:%s\n", strerror(errno));// 如果开拓失败，输入错误信息
    return 1;
}

正文完

程序员

发表至：程序员

2024-02-28

0

关于程序员:只会一种编程语言没关系-AI代码转换工具来帮你

关于程序员:jtday15

关于程序员:JavaScript-DOM编程艺术第2版的简单总结

关于程序员:国学无用关于国学的思考田康苏

关于go:Java-函数方法指南如何获取给定日期的月份最后一天

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

1. strncmp() 函数

1.1 用法

1.2 实例

1.3 实现 strncmp()

2. strncpy() 函数

2.1 用法

2.2 实例

2.3 实现 strncpy() 函数

3. strncat() 函数

3.1 用法

3.2 实例

3.3 实现 strncat() 函数

4. strtok() 函数

4.1 用法

4.2 实例

4.3 实现 strtok() 函数

5. strerror() 函数

5.1 用法

5.2 实例

站内搜索