开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> C语言--字符串操作函数、内存操作函数介绍及模拟实现 -> 正文阅读

[C++知识库]C语言--字符串操作函数、内存操作函数介绍及模拟实现

前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。
字符串常量适用于那些对它不做修改的字符串函数。

C语言中常用的字符串函数有：

1、求字符串长度

strlen

2、长度不受限制的字符串函数

strcpy 、strcat 、strcmp

3、长度受限制的字符串函数介绍

strncpy 、strncat 、strncmp

4、字符串查找

strstr 、strtok

5、错误信息报告

strerror

6、字符操作

内存操作函数： memcpy 、memmove 、memset 、memcmp

提示：以下是本篇文章正文内容，下面案例可供参考

一、函数介绍

1.1 strlen

函数原型：

 size_t strlen ( const char * str );

该函数用于计算某字符串的长度，即字符串中字符个数。

字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束，否则会返回随机值。
注意函数的返回值为size_t，是无符号的（易错）。
注意函数的参数时char*类型，故需传入指针或者地址。

使用示例：

int main()
{
    char arr[] = "china";
    char* pa = "people";
    printf("%d\n", strlen(arr));
    printf("%d\n", strlen(pa));

    return 0;
}

在这里插入图片描述
易错示例：

int main()
{
    const char* str1 = "abcdef";
    const char* str2 = "bbb";
    if (strlen(str2) - strlen(str1) > 0)
    {
        printf("str2>str1\n");
    }
    else
    {
        printf("srt1>str2\n");
    }
    return 0;
}

此代码明显是str2<str1，但是使用库函数还是会出现str2>str1，这是因为strlen函数的返回值是无符号型。虽然strlen(str2) - strlen(str1)得到的结果是-3，但其类型还是无符号类型，所以计算机在解读时不会注意到它的符号位，而是把-3解读成一个很大的正数，导致这里出现错误！

1.2 strcpy

函数原型：

char* strcpy(char * destination, const char * source );

该函数用于复制字符串。将source字符串的内容复制到destination中。其返回值是目标空间原本的起始地址。
注意，即使源字符串短于目标字符串，也会直接全覆盖掉目标字符串。

源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。

使用示例：

int main()
{
    char arr1[20] = " ";
    char* arr2 = "hello";
    strcpy(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

1.3 strcat

函数原型：

char * strcat ( char * destination, const char * source );

该函数用以字符串追加。将源字符串的内容追加到目标字符串后面。其返回值是目标空间原本的起始地址。

源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？
是不可以给自己追加的！因为自己给自己追加时会把结束标志’\0’覆盖掉，找不到结束标志，程序将进入死循环。

使用示例：

int main()
{
    char arr1[20] = "hello";
    char* arr2 = " world";
    strcat(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

在这里插入图片描述

1.4 strcmp

函数原型：

int strcmp ( const char * str1, const char * str2 );

此函数用于比较两个字符串大小。比较时从第一个字符开始比较，若第一个字符相同则比较第二个字符，依次往后，直到遇见不相等的字符。如果最后一个字符即两个字符串的结束标志’\0’比完还相等，就说两个字符串相等。

第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
那么如何判断两个字符串？

使用示例：

int main()
{
    char ch1[] = "abcdef";
    char* ch2 = "abcdff";
    if (strcmp(ch1, ch2) > 0)
    {
        printf("ch1 > ch2\n");
    }
    else printf("ch1 <= ch2\n");
}

在这里插入图片描述

1.5 长度受限制的字符串函数strncpy、strncat、strncmp

前面提到的几个strcpy、strcat、strcmp函数使用时无需考虑字符串长度。那么如果我们需要指定复制、追加、比较时字符串的某几位该如何呢？strn系列字符串函数应运而生。下面介绍这三个字符串函数的使用：

1.5.1 strncpy

函数原型：

char * strncpy ( char * destination, const char * source, size_t num );

该函数用以拷贝num个字符从源字符串到目标空间。

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个。

使用举例：

int main()
{
    char des[] = "abcdef";
    char* src = "opqs";
    strncpy(des, src, 2);
    printf("%s\n", des);
    return 0;
}

在这里插入图片描述
可以看到，该函数只将源字符串的前两位拷贝到目标字符串的前两位，目标字符串剩下的内容都没有变化！

1.5.2 strncat

函数原型：

char * strncat ( char * destination, const char * source, size_t num );

使用示例：

int main()
{
    char des[20] = "hello ";
    char* src = "worldertid";
    strncat(des, src, 5);
    printf("%s\n", des);
    return 0;
}

在这里插入图片描述
可以看到，只将src里的前5个字符追加到des中了。

1.5.3 strncmp

函数原型：

int strncmp ( const char * str1, const char * str2, size_t num );

使用示例：

int main()
{
    char* des = "abcd";
    char* src = "accd";
    printf("%d\n", strncmp(des, src, 2));
    return 0;
}

比较两个字符串前两个字符的大小。

1.6 strstr

函数原型：

char * strstr ( const char *str1, const char * str2);

该函数用于在str1中查找str2，如果找到str2了，就返回在str1中第一次出现str2时的首字符的地址。如果str1中找不到str2，就返回一个空指针。

使用示例：

int main()
{
    char* str[2] = { "abcdefg","cde" };//使用了一个指针数组
    
    char* ret = strstr(str[0], str[1]);//在str[0]里找str[1]

    if (ret == NULL)
    {
        printf("没找到\n");
    }
    else
    {
        printf("找到了：%s\n", ret);
    }
    return 0;
}

结果：
在这里插入图片描述

1.7 strtok

函数原型：

char * strtok ( char * str, const char * sep );

sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数str指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

该函数用来对某一个字符串按照指定的分隔符进行分割，需要注意的是，这个函数并非调用一次就可以分割出全部的字符串，而是在第一次调用后，需要将第一个参数换成空指针NULL，直到把所有的分割的字符串都分割出来。

使用示例：

/* strtok example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
 {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
 }
  return 0;
}

在这里插入图片描述

int main()
{
    char* p = "bozqjyb@163.com";
    const char* sep = ".@";
    char arr[30];
    char* str = NULL;
    strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
    for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    {
        printf("%s\n", str);
    }
}

在这里插入图片描述

1.8 strerror

函数原型：

char * strerror ( int errnum );

给该函数传入相应参数后，会返回参数对应的错误内容，即参数其实就是错误代码！

使用举例：

int main()
{
    FILE* pFile;
    pFile = fopen("unexist.ent", "r");
    if (pFile == NULL)
        printf("%s\n", strerror(errno));//errno里放的就是上一次错误代码
    //errno: Last error number
    return 0;
}

在这里插入图片描述
可以看到这里因为打开文件失败，系统的错误码打印出来是这样的内容。

1.9 perror

函数原型：

void perror ( const char * str );

perror其实和strerror一样，都是打印错误信息的函数，但是perror的使用则更简单：它是直接将错误码errno中的内容打印出来。在打印错误信息之前会先打印你自己传过去的字符串并加上一个冒号。

使用举例：

int main()
{
    FILE* pFile;
    pFile = fopen("unexist.ent", "r");
    if (pFile == NULL)  perror("FOPEN");
    return 0;
}

在这里插入图片描述

1.10 字符分类函数

下表是关于一些字符分类函数，该系列函数的头文件位ctype.h

函数	如果函数内是以下参数就返回真值
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’
isdigit	十进制数字 0~9
isxdigit	十六进制数字：0-9、A-F、a-f
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或者数字，a~z,A~Z,0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

当字符分类函数的参数符合表中所述，那该函数就会返回真值！

使用举例：

#include <ctype.h>
int main()
{
    char ch1 = '#';
    char ch2 = '5';
    int ret1 = isdigit(ch1);
    int ret2 = isdigit(ch2);
    printf("'#'返回：%d\n'5'返回：%d\n", ret1, ret2);
    return 0;
}

在这里插入图片描述
可以看到，当参数是数字字符时，isdigit函数返回的是一个真值4。当参数不是数字字符时，返回0，是一个假值。

1.11 memcpy

函数原型：

void * memcpy ( void * destination, const void * source, size_t num );

该函数用以将源空间*source的前num个字节的内容拷贝到目标空间*destination中去。注意第三个参数的单位是字节。

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0’的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。可以使用memmove解决内存重叠的复制。

使用举例：

int main()
{
    int arr1[10] = {1,2,3,4,5,6,7,8,9,10};
    int arr2[10] = { 0 };
    memcpy(arr2, arr1, 20);
    //这里是将arr1中的前5个数据复制到arr2中去。
    //注意，因为第三个参数单位是字节，这里是int数组，所以前5个数据大小是20个字节
    //第三个参数要填写20，而不是5！！！
    for (int i = 0; i < 5; i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

在这里插入图片描述
这里是将arr1中的前5个数据复制到arr2中去。
注意，因为第三个参数单位是字节，因为这里是int数组，所以前5个数据大小是20个字节！
第三个参数要填写20，而不是5！！！

1.12 memmove

函数原型：

void * memmove ( void * destination, const void * source, size_t num );

该函数和memcpy差不多用法，但是可以用在源空间和目标空间存在内存重叠的情况下。

使用举例：

int main()
{
    int arr1[10] = {1,2,3,4,5,6,7,8,9,10};
    int arr2[10] = { 0 };
    memmove(arr1+3, arr1, 20);
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

在这里插入图片描述

1.13 memcmp

函数原型：

int memcmp ( const void * ptr1, 
 const void * ptr2, 
 size_t num );

此函数用以比较从ptr1和ptr2指针开始的num个字节，其返回值和strcmp的设置是非常相似的。
即：前num个字节比较后，如果ptr1>ptr2就返回大于0的数；如果ptr1=ptr2就返回0；如果ptr1<ptr2就返回小于0的数。

使用举例：

int main()
{
    float arr1[] = { 1.0,2.0,3.0,4.0 };
    float arr2[] = { 1.0,2.0,5.0 };
    int ret = memcmp(arr1, arr2, 8);
    printf("%d\n", ret);
    return 0;
}

在这里插入图片描述
可以看到，因为前8个字节中，arr1和arr2都是1.0和2.0，是相等的，所以返回0。

1.14 memset

函数原型：

void * memset ( void * ptr, int value, size_t num );

内存设置函数。该函数可以以字节为单位设置内存内容。即将ptr所指向的地址的前num个字节的内容设置为value的值。

使用举例：

int main()
{
    int arr[10] = { 0 };
    memset(arr, 1, 20);//将arr的前20个字节都设置为1
}

在这里插入图片描述
观察内存状态，发现arr的前20个字节，每个字节都被设置为1。

在这里插入图片描述
因为int有4个字节大小，16进制的情况下，0x01010101的十进制就是16843009，所以arr数组前5个元素（4x5=20个字节）都被设置为16843009了。

二、库函数模拟实现

2.1 模拟实现strlen

思路：给字符串一个起始地址，往后数，遇到’\0’就停止。

1.计数器实现：

int my_strlen(const char* str)
{
    int count = 0;
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

2.递归函数实现：

int my_strlen(const char* str)
{
    if (*str == '\0')
    {
        return 0;
    }
    else return 1 + my_strlen(str + 1);
}

3.指针运算实现：
这里是使用的思路是：指针-指针的结果为两指针之间的长度。

int my_strlen(const char* str)
{
    char* p = str;
    while (*str != '\0')
    {
        str++;
    }
    return str - p;
}

2.2 模拟实现strcpy

思路：在检测到’\0’前将源字符串逐个复制到目标字符串中。
注意：断言、返回值

char* my_strcpy(char* str1, const char* str2)
{
    char* ret = str1;
    assert(str1 != NULL && str2 != NULL);
    while (*str2 != '\0')
    {
        *str1 = *str2;
        str1++;
        str2++;
    }
    return ret;
}

2.3 模拟实现strcat

思路：要把源字符放到目标字符串中去，最关键是要找到目标字符串开始复制的起点，也就是目标字符串原本内容的结束标志’\0’。剩下的和strcpy的实现就一样了。

char* my_strcat(char* des, const char* src)
{
    char* ret = des;
    assert(des != NULL && src != NULL);
    while (*des != '\0')
    {
        des++;
    }//这一步就是找到目标字符串原本内容的结束点
    
    while (*des++ = *src++)
    {
        ;
    }
    return ret;
}

2.4 模拟实现strcmp

思路：逐个比较两个字符串的相同位置的字符的大小。相等就后移一位，直到不相等的出现，将字符1和字符2的差值返回。或者比到最后一位两个字符串都是’\0’还相等，就返回0。

int my_strcmp(const char* str1, const char* str2)
{
    while (*str1 == *str2)
    {
        str1++;
        str2++;
        if (*str1 == '\0' && *str2 == '\0')
        {
            return 0;
        }
    }
    return (*str1 - *str2);;
}

2.5 模拟实现strstr

思路：需注意回溯！因为对到一半对不上了，那么必须返回str1上一次开始对的下一个字符去，因此需要一个额外的指针cp来标记上一次开始对的位置！

char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);
    char* str1s = str1;
    char* str2s = str2;//记录一下这两个指针的开头
    char* cp = str1;//一个标志指针，用以当出现核对一半发现不同的时候让str1进行回溯。
    while (*cp)
    {
        str1 = cp;//回溯
        str2 = str2s;
        while (*str1 && *str2 && (*str1 == *str2))//如果两个字符串字母相同且都不是终止符号'\0'，比如两个都到终点了，就必须跳出来，否则还会继续++，产生越界访问
        {
            str1++;
            str2++;//各进一步核对下一位
        }
        if (*str2 == '\0')//str2核对完了，都相同，就返回记录起始位置的cp
        {
            return cp;
        }
        cp++;//对一半发现不一样了，就让标志str1的指针进一步
    }
    return NULL;//把str1都比对完了也没发现相同的，返回空指针
}

2.6 模拟实现memcoy

思路：和strcpy的思路一样，但是需要注意这个函数的参数都是void*类型的，不能直接进行解引用和自加。需要先强制转化为char*类型，再进行和strcpy类似的操作。同时要使用到第三个参数num，用第三个参数做一个循环，来达到复制num个字节的目的。

void* my_memcpy(void* des, const void* src, int num)
{
    void* ret = des;
    assert(des && src);
    char* desm = (char*)des;
    char* srcm = (char*)src;//强制转化为char*
    for (int i = 0; i < num; i++)
    {
        *desm = *srcm;
        desm++;
        srcm++;
    }
    return ret;
}

2.7 模拟实现memmove

关键在于判断复制时是从前往后复制还是从后往前复制，判断正确才能保证重叠部分数据不会因为覆盖而产生重复！

void* my_memmove(void* des, const void* src, size_t num)
{
    void* ret = des;
    assert(des && src);
    char* srcm = (char*)src;
    char* desm = (char*)des;
    if (des < src)//目标内存空间在前，从前往后
    {
        while (num--)
        {
            *desm = *srcm;
            desm++;
            srcm++;
        }
    }
    else//目标内存空间在后，从后往前
    {
        while (num--)
        {
            *(desm + num) = *(srcm + num);
        }
    }

    return ret;
}