目录

本章重点

函数介绍

求字符串长度

strlen

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

strcpy

strcat

strcmp

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

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

字符分类函数：

字符转换函数：

内存操作函数

memcpy

memmove

memset--内存设置

memcmp

本章重点

重点介绍处理字符和字符串的库函数的使用和注意事项

函数介绍

求字符串长度

strlen

size_t sstrlen(const char* str);

返回字符串str的字符串个数

字符串以''作为结束标志，strlen函数返回的是在字符串中''前面出现的字符个数（不包含'').

参数指向的字符串必须要以''结束。

注意函数的返回值为size_t，是无符号的（易错）

学会strlen函数的模拟实现

#include
#include
int main() 
{
    const char* str1 = "abcdef";
    const char* str2 = "bbb";
    if (strlen(str2) - strlen(str1) > 0)
    {
        printf("hehen");
    }
    else
    {
        printf("hahan");
    }
    return 0;
}

strlen的返回值是unsigned int类型

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

strcpy

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

Copies the C string pointed bt source into the array pointed by destination, including the terminating null character (and stopping at that point);

将字符串source复制到destination中

源字符串必须以''结束。

会将源字符串的''拷贝到目标空间。

目标空间必须足够大，以确保能存放源字符串。

目标空间必须可变。

学会模拟实现：

#include
#include
#include
char* my_strcpy(char* dest,const char* src)
{
    assert(dest != NULL);
    assert(src != NULL);
    char* ret = dest;
    //拷贝src指向的字符串到dest指向的空间，包含''
    while (*dest++ = *src++)
    {
        ;
    }
    //返回目的空间的起始地址
    return ret;
}
int main() 
{
    char arr1[] = "abcdefghi";
    char arr2[] = "bit";
    //strcpy(arr1, arr2);
    my_strcpy(arr1, arr2);
    printf("%sn", arr1);
    return 0;
}

strcat

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

将字符串source插入到字符串desctination后面

源字符串必须以''结束。

目标空间必须足够大，能容纳下源字符串的内容。

目标空间必须可修改。

代码模拟实现：

#include
#include
#include
char* my_strcat(char* dest,const char* src)
{
    assert(*dest && src);
    char* ret = dest;
    //1.找到目的字符串的''
    while (*dest != '')
    {
        dest ++ ;
    }
    //2.追加
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main() 
{
    char arr1[30] = "hello";
    char arr2[] = "world";
    //strcat(arr1, arr2);
    my_strcat(arr1, arr2);
    printf("%sn", arr1);
    return 0;
}

字符串自己给自己添加如何？

因为追加时将自身的''给覆盖了，所以src寻找''时就找不到了，会出现乱码。

strcmp

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

比较字符串str1和str2的大小，从左往右依次比较字符ASCII码值。

标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字。

第一个字符串等于第二个字符串，则返回0。

第一个字符串小于第二个字符串，则返回小于0的数字。

那么如何判断两个字符串？

代码模拟实现：

#include
#include
#include
int my_strcmp(const char* str1,const char* str2)
{
    assert(str1 && str2);
    //比较
    while (*str1 == *str2)
    {
        if (*str1 == '')
        {
            return 0;//相等
        }
        str1++;
        str2++;
    }
    if (*str1 > *str2)
        return 1;//大于
    else
        return -1;//小于
}
int main() 
{
    char arr1[30] = "hello";
    char arr2[] = "world";
    //strcat(arr1, arr2);
    int ret = my_strcmp(arr1, arr2);
    printf("ret = %dn", ret);
    return 0;
}

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

下列函数跟上述字符串函数功能一样，只是多加一个参数表示使用几个字符

strncpy

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

拷贝num给字符从源字符串到目标空间

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

strncat

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

如果源字符串的长度小于num，也不会多加其余操作，只是将源字符串加入目标空间后就结束。

strncmp

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

字符串查找

strstr

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

在str1中查找字符串str2，并返回地址，如果没找到则返回空指针

代码模拟实现：

#include
#include
#include
char* my_strstr(const char* p1,const char* p2)
{
    assert(p1 && p2);
    char* s1 = NULL;
    char* s2 = NULL;
    if (*p2 == '')
    {
        return (char*)p1;
    }
    char* cur = (char*)p1;
    while (*cur)
    {
        s1 = cur;
        s2 = (char*)p2;
        while (*s1 && s2 && !(*s1 - *s2))
        {
            s1++;
            s2++;
        }
        if (*s2 == '')
        {
            return (char*)cur;//找到子集
        }
        cur++;
    }
    return NULL;//找不到子集
}
int main() 
{
    const char *p1 = "abcdef";
    const char *p2 = "def";
    char* ret = my_strstr(p1, p2);
    if (ret == NULL)
    {
        printf("子串不存在n");
    }
    else
        printf("%sn", ret);
    return 0;
}

strtok

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

将字符串str按照sep字符串里的字符进行分割。

sep参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了0给或者多个由sep字符串中的一个或者多个分隔符分割的标记。

strtok函数找到str中的下一个标记，并将其用结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

strtok函数是第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

如果字符串中不存在更多的标记，则返回NULL指针。

#include
#include
#include
int main() 
{
    //点分十进制的表示方法
    char arr[] = "123.234.456@.78";
    const char* p = "@.";
    char buf[1024] = { 0 };
    strcpy(buf, arr);
    //切割buf中的字符串
    char* ret = NULL;
    for (ret = strtok(buf, p); ret != NULL; ret = strtok(NULL, p))
    {
        printf("%sn", ret);
    }

    return 0;
}

错误信息报告

strerror

char* strerror(int errnum);

返回错误码，所对应的错误信息。

#include
#include
#include
int main() 
{
    //错误码   错误信息
    //0-       No error
    //1-       Operation not permitted
    //2-       No such file or directory
    //...      ...
    //打开文件
    FILE* pf = fopen("test.txt", "r");

    if (pf == NULL)
    {
        printf("%sn", strerror(errno));
    }
    else
    {
        printf("open file successn");
    }

    return 0;
}

errno是一个全局的错误码的变量,想要使用需要引用头文件。

当c语言的库函数在执行过程中，发生了错误，就会把对应的错误码赋值到errno中。

字符分类函数：

字符转换函数：

int tolower(char c);

int toupper(char c);

内存操作函数

memcpy

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

函数memcpy从source 的位置开始向后复制num个字节的数据destination的内存位置。

这个函数在遇到''的时候并不会停下来。

如果source和destination有任何的重叠，复制的结果都是未定义的。

#include
#include
#include
void* my_memcpy(void* dest, const void* src, size_t num)
{
    void* ret = d;
    assert(dest && src);
    while (num--)
    {
        *(char*)dest = *(char*)src;
        ++(char*)dest;
        ++(char*)src;
    }
    return ret;
}
int main() 
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[5] = { 0 };
    //memcpy(arr2, arr1, sizeof(arr1));
    my_memcpy(arr2, arr1, sizeof(arr1));
    return 0;
}

在c语言标准中，memcpy只要能处理不重叠的内存的拷贝就可以。 

memmove

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

和memcpy的差别就是memmove函数处理的原内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

#include
#include
#include
void* my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if (dest < src)
    {
        //前->后
        while (num--)
        {
            *(char*)dest = *(char*)src;
            ++(char*)dest;
            ++(char*)src;
        }
    }
    else
    {
        //后->前
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    
    return ret;
}
int main() 
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[5] = { 0 };
    my_memmove(arr1 + 2,arr1,20);
    return 0;
}

memset--内存设置

#include
#include

int main() 
{
    int arr1[] = { 0 };
    //40个字节
    //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ...
    memset(arr1, 1, 10);//这里的10是修改十个字节
    //01 01 01 01 01 01 01 01 01 01 00 00 00 00 00 00 ...
    return 0;
}

这里的10是修改十个字节

memcmp

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

比较从ptr1和ptr2指针开始的num个字节

返回值如下：

#include
#include

int main() 
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[5] = { 1,2,5,4,3 };
    int ret = memcmp(arr1, arr2, 8);
    printf("%d", ret);
    return 0;
}