目录

•  ⏳ 前言 ⏳
•  ⚽本章重点
•  ⛳一、求字符串长度函数
  •  1.strlen
•  ✊二、长度不受限制的字符串函数
  •  1.strcpy
  •  2.strcat
  •  3.strcmp
•  ✋三、长度不限制的字符串函数
  •  1.strncpy
  •  2,strncat
  •  3.strncmp
•  ⚾四、字符串查找
  •  1.strstr
  •  2.strtok
•  ⛳五、误信息报告函数
  •  1.strerror
•  ⌚六、字符操作
  •  1.字符分类函数
  •  2.字符转换函数：
•  ✨七、内存操作函数
  •  1.memcpy
  •  2.memmove
  •  3.memcmp（简单了解）
  •  4.memset（简单了解）

⏳ 前言 ⏳

本篇文章将会详细介绍和学习字符串操作函数，重点介绍处理字符和字符串的库函数和字符操作分类改写函数，内存操作函数的使用和注意事项，还有自己模拟实现该函数的代码练习。

⚽本章重点

求字符串长度

• strlen

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

• strcpy
• strcat
• strcmp

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

• strncpy
• strncat
• strncmp

字符串查找

• strstr
• strtok

误信息报告

• strerror

字符操作

内存操作函数

• memcpy
• memmove
• memset
• memcmp

⛳一、求字符串长度函数

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

1.strlen

在之前学习中，我们会经常使用一个字符串函数求字符串的长度-- strlen。

strlen求字符串长度的算法分析：strlen接收到字符串起始位置的地址时，比较该地址处的内容是否为’\0’，若不为’\0’, 直到找到 /0 为止

图解：

函数介绍：strlen

size_t strlen(const char* str);

头文件：string.h

函数名：strlen

函数参数：str，参数类型是const char* ，即需要进行求字符串长度的起始地址

函数返回类型： size_t，size_t是unsigned int的类型重定义，是无符号整型。库函数使用size_t类型可能考虑的是字符串的长度不可能是负数，所以用了无符号类型size_t。

函数功能：计算字符串的长度

重点内容：

（1）字符串以’\0’作为结束标志，strlen函数返回的是在字符串中’\0’前面出现的字符个数（不包含’\0’)。

（2）参数指向的字符串必须要以’\0’结束。（如果没有’\0’，可能会出现随机值）

（3）注意函数的返回值为size_t(可以理解为unsigned)，是无符号的(易错)（strlen(“abc”) - strlen("abcdef) < 0为假，注意strlen返回类型)

（4）学会strlen函数的模拟实现

strlen函数的模拟实现三种方法：

①计数器方法
②递归方法（不创建临时变量求字符串长度）
③指针 - 指针方法

#include<stdio.h>
#include<assert.h>
//1.计数器实现求字符串长度函数
    int my_strlen1(const char* str)//整个过程不改变指针指向内容，加上const
{
    assert(str != NULL);//加上断言，防止接收空指针
    int count = 0;
    while (*str != '\0')//也可以直接用while(*str)
    {
        count++;
        str++;
    }
    return count;
}

//2.递归实现求字符串长度，不用创建临时变量
int my_strlen2(const char* str)
{
    assert(str != NULL);
    if (*str != '\0')//也可以直接用if(*str)
    {
        return 1 + strlen(str + 1);//不能直接使用str++，可以使用++str,建议直接用str+1
    }
    else
        return 0;
}

//3.指针-指针得到中间元素的个数，实现求字符串长度
int my_strlen3(const char* str)
{
    assert(str != NULL);
    const char* tmp = str;//创建临时指针变量保存str起始值
    while (*str != '\0')
    {
        str++;
    }
    return str - tmp;
}

int main()
{
    char arr[] = "abcdefgh";
    int ret1 = my_strlen1(arr);//1.计数器方法
    int ret2 = my_strlen2(arr);//2.递归方法
    int ret3 = my_strlen3(arr);//3.指针 - 指针方法
    printf("%d\n", ret1);
    printf("%d\n", ret2);
    printf("%d\n", ret3);
    return 0;
}

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

1.strcpy

如果我们要将一个字符串的内容拷贝到另外一个字符串空间中时，需要使用字符串拷贝- -strcpy函数，在正式介绍strcpy函数之前，我们先看一段代码：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "abcdefghik";
    char arr2[] = "hello";
    //将字符串arr2拷贝给arr1
    //不能些arr1 = arr2 因为数组名表示首元素地址
    strcpy(arr1, arr2);
    //用调试窗口观察arr1变化
    return 0;
}

strcpy函数进行字符串拷贝的算法分析：

函数介绍：strcpy
char* strcpy(char* destination，const char* source);
头文件：string.h
函数名：strcpy
函数参数：
参数1：destination, 类型：char* ，表示将字符串拷贝的目的地位置
参数2：source，类型：char* ，表示被拷贝字符串拷贝的源地址起始位置。
函数返回类型： char*, 实际上就是返回destination（目的地）的起始位置
函数功能：字符串拷贝

重点内容：

（1） Copies the C string pointed by source into the array pointed by
destination, including the terminating nulcharacter(and stopping at that point).
（2）源字符串必须以‘\0’结束。 （源字符串如果没有’\0’, 那么strcpy在拷贝的时候，不知道什么时候停止，可能会造成越界访问）
（3）会将源字符串中的’ \0 ’拷贝到目标空间。
（4）目标空间必须足够大，以确保能存放源字符串。 （目标空间不够大，也会导致越界访问）
（5）目标空间必须可变（不能是常量字符串，比如:char* arr1 =“asdsffdf”）
（要将源字符串的内容拷贝到目标空间，目标空间当然要可以变化，才能接收拷贝过来的字符）
（6）学会模拟实现。

模拟实现strcpy

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
    assert(dest != NULL);
    assert(src != NULL);
    char* ret = dest;//储存原字符串首字符地址

//拷贝src指向字符串的内容到dest指向的空间，包括'\0'
    //方法一：常规思路版
    while (*src != '\0')
    {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = *src;

//方法二：代码精简版
    while (*dest++ = *src++)//遇到‘/0’为0，循坏停止
    {
        ;
    }
    //返回目的空间起始位置
    return ret;
}
int main()
{
    char arr1[] = "abcdefghik";
    char arr2[] = "hello";
    my_strcpy(arr1, arr2);//模拟实现strcpy函数
    printf("%s", arr1);
    return 0;
}

2.strcat

如果我们要将一个字符串的内容追加到另外一个字符串的末尾空间中时，需要使用字符串拷贝-- - strcat函数，在正式介绍strcat函数之前，我们先看一段代码：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[30] = "hello";
    //arr1空间需要足够大来接收追加过来的内容
    //否则会造成越界访问
    char arr2[] = "world";
    //将字符串arr2内容追加给arr1
    strcat(arr1, arr2);
    printf("%s", arr1);
    return 0;
}

strcat在进行追加的时候是否会将’\0’追加过去？

strcat函数进行字符串追加的算法分析：

函数介绍：strcat
char* strcat(char* destination，const char* source);
头文件：string.h
函数名：strcat
函数参数：
参数1：destination, 类型：char* ，表示将字符串追加的目的地位置
参数2：source，类型：char* ，表示被追加字符串的源地址起始位置。
函数返回类型： char,实际上就是返回destination（目的地）的起始位置*
函数功能：字符串追加

重点内容：

（1）Appends a copy of the source string to the destination string.The
terminating null character in destination is overwritten by the first character of source, and a null - character is included at the end ofthe new string formed by the concatenation of both in destination.
（2）源字符串必须以‘\0’结束。目标空间也必须包含’\0’,以确定追加的起始位置
（3）目标空间必须有足够的大，能容纳下源字符串的内容。
（4）目标空间必须可修改。
（5）字符串自己给自己追加，如何 ?
用strcat自己给自己追加会导致程序崩溃，无法实现自己追加自己！（从’\0’开始追加，自己追加自己的时候，’\0‘改成了被追加的首字符，再寻找追加字符串结束的’\0’时，找不到’\0’，会导致死循环）

的模拟实现strcat

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
    assert(dest != NULL);
    assert(src != NULL);
    char* dest_start = dest;
    
    //1.找到目的空间中的'\0'
    while (*dest != '\0')//跳过不是'\0'的字符
    {
        dest++;
    }
    //2.追加
    while (*dest++ = *src++)
    {
        ;
    }
    return dest_start;
}

int main()
{
    char arr1[30] = "hello";
    char arr2[] = "world";
    my_strcat(arr1, arr2);//模拟实现strcat
    printf("%s", arr1);
    return 0;
}

思考：strcat为什么不能自己追加自己？

strcat从’\0’开始追加，自己追加自己的时候，’\0‘改成了被追加的首字符，再寻找追加字符串结束的’\0’时，找不到’\0’，会导致死循环。

怎么样才能自己追加自己呢？
使用strncat函数，后面会进行详细讲解

3.strcmp

如果我们要比较两个字符串的是否相等，或者比较字符串大小，不能用操作符 == 来直接进行判断，而是需要用到字符串比较函数strcmp

strcmp函数进行字符串追加的算法分析：

函数介绍：strcmp int strcmp(const char* str1，const char* str2);
头文件：string.h
函数名：strcmp
函数参数：
参数1：str1, 类型：char* ，表示将进行比较的第一个字符串
参数2：参数2：str2, 类型：char* ，表示将进行比较的第二个字符串
函数返回类型： int, 返回两个字符串比较的结果
函数功能：字符串比较

重点内容：

（1）This function starts comparing the first character of each string.lf they are equal to each other, itcontinues with the following pairs until the characters differ or until a terminating null - character isreached.
标准规定︰

（2）第一个字符串大于第二个字符串，则返回大于O的数字。
（3）第一个字符串等于第二个字符串，则返回0
（4）第一个字符串小于第二个字符串，则返回小于0的数字

strcmp那么如何判断两个字符串？ 逐个字符ASCLL码进行比较

模拟实现strcmp

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* p1, const char* p2)
{
    assert(p1 && p2);
    while (*p1 == *p2)
    {
        if (*p1 == '\0')
        {
            return 0;
        }
        p1++;
        p2++;
    }

//方法一：vs实现的方式
if (*p1 > *p2)
{
    return 1;
}
else
{
    return -1;
}

//方法二：linux下gcc实现方式
  int my_strcmp(const char* p1, const char* p2)
{
    return *p1 - *p2;
}

int main()
{
    char* p1 = "abc";
    char* p2 = "ab";
    int ret = my_strcmp(p1, p2);
    printf("ret = %d", ret);
    return 0;
}