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

42次阅读

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

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

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

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

1. strncmp() 函数

1.1 用法

  1. 申明：int strncmp(const char str1, const char str2, size_t n)
  • str1 — 要进行比拟的第一个字符串。
  • str2 — 要进行比拟的第二个字符串。
  • n — 要比拟的最大字符数。
  1. 作用：把 str1 和 str2 进行比拟，最多比拟前 n 个字符
  2. 返回值:
  • 如果返回值 < 0，则示意 str1 小于 str2。
  • 如果返回值 > 0，则示意 str1 大于 str2。
  • 如果返回值 = 0，则示意 str1 等于 str2。

1.2 实例 

#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

1.3 实现 strncmp()

思路：总体思路与 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;
}

2. strncpy() 函数

2.1 用法

  1. 申明：char strncpy(char dest, const char *src, size_t n)
  • dest — 指向用于存储复制内容的指标数组。
  • src — 要复制的字符串。
  • n — 要从源中复制的字符数。
  1. 作用：把 src 所指向的字符串复制到 dest，最多复制 n 个字符。当 src 的长度小于 n 时，dest 的残余局部将用‘\0’填充。

2.2 实例

​ 当 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

2.3 实现 strncpy() 函数

思路：总体实现思路和 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;  // 返回数组的首地址
}

3. strncat() 函数

3.1 用法

  1. 申明：char strncat(char dest, const char *src, size_t n)
  • dest — 指向指标数组，该数组蕴含了一个 C 字符串，且足够包容追加后的字符串，包含额定的空字符。
  • src — 要追加的字符串。
  • n — 要追加的最大字符数。

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

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

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

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

3.2 实例

​ 当 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;
}

3.3 实现 strncat() 函数

思路：也和 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 字符串起始地址
}

4. strtok() 函数

4.1 用法

  1. 申明：char strtok(char str, const char *delim)
  • str — 要被分解成一组小字符串的字符串。第一次调用 strtok() 时，这个参数应该是你想要宰割的字符串。随后的调用应该将此参数设置为 NULL，以便持续从上次的地位宰割。
  • delim — 蕴含分隔符的 C 字符串。
  1. 作用：strtok() 用于将字符串宰割成一系列的子串
  2. 返回值：该函数返回被合成的第一个子字符串，如果没有可检索的字符串，则返回一个空指针。

4.2 实例 

#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() 就是把从指标字符串中，以分隔符为标记，将其分成若干个子串，并且须要屡次调用”

4.3 实现 strtok() 函数

思路剖析：

第一步：

先判断是否为第一次传入

第二步：

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

  1. 首先断定 p1 中首元素是否须要切割（在 p2 中排查直到遇见‘\0’）。
  2. 如果匹配胜利，让 pp+ 1 指向下一个元素，让 p3 从新指向 p2 的首元素，持续排查下一个元素。
  3. 如果排查失败，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;
}

5. strerror() 函数

5.1 用法

  1. 申明：char *strerror(int errnum)
  • errnum — 谬误号，通常是 errno。
  1. 作用：从外部数组中搜寻谬误号 errnum，并返回一个指向谬误音讯字符串的指针。strerror 生成的谬误字符串取决于开发平台和编译器。
  2. 返回值：该函数返回一个指向谬误字符串的指针，该谬误字符串形容了谬误 errnum。

5.2 实例 

#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
关于程序员:Python-异常处理方式汇总建议收藏
关于程序员:Jmeter压测工具使用之HetuEngine压力测试
关于程序员:华为的数通认证需要考几科费用是多少
关于程序员:我理解的程序员成长路线