玩转C语言库函数。包含strlen、strcpy、strcmp、strcat、memcmp、memmove、strstr等等常用的库函数

前言

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

• IO函数
• 字符函数
• 内存函数
• 时间日期函数
• 数学函数

strlen

strlen函数的介绍：

size_t strlen ( const char * str );
size_t = unsigned int 

char arr[]="abcdef";
strlen("abcdef");//字符串abcdef作为表达式来讲得到的是首元素的地址
strlen(arr);

1、工作原理：从起始地址开始，到\0结束，计数值从0开始，中间每跳过一个元素，计数值+1。
2、字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
3、参数指向的字符串必须要以 ‘\0’ 结束。
4、注意函数的返回值为size_t，是无符号的（ 易错 ）
5、学会strlen函数的模拟实现
1）计数器

size_t My_strlen1(const char* arr)
{
	assert(arr);
	size_t count = 0;
	while (*arr++)
	{
		count++;
	}
	return count;
}

2）指针-指针

size_t My_strlen3( char* arr)
{
	assert(arr);
	char* start = arr;
	while (*arr)
	{
		arr++;
	}
	return arr - start;
}

3）递归

size_t My_strlen2(const char* arr)
{
	assert(arr);
	if (*arr)
	{
		return 1 + My_strlen2(arr + 1);
	}
	else
	{
		return 0;
	}
}

6、strlen使用时的注意

int main()
{
    if(strlen("abc")-strlen("abcdef")>0)
    {
        printf("hehe\n");
    }
    else
    {
        printf("biubiu");
    }
    return 0;
    //打印的hehe
    //虽然从数值上讲得到了-3，因为strlen返回值为size_t类型的
    //所以-3会被理解成无符号数，他的值一定大于0
    //如果想实现正常逻辑，要进行强制类型转换
      if((int)(strlen("abc")-strlen("abcdef"))>0)
    {
        printf("hehe\n");
    }
    else
    {
        printf("biubiu");
    }
}

strcpy字符串拷贝

strcpy函数的介绍

char* strcpy(char * destination, const char * source );
//将原指针指向的字符串拷贝到目的指针指向的字符串里面去,包含\0
//将source指向的字符串拷贝到destination指向的空间里去

1、源字符串必须以 ‘\0’ 结束。
2、会将源字符串中的 ‘\0’ 拷贝到目标空间。
3、目标空间必须足够大，以确保能存放源字符串。
4、目标空间必须可变。
5、strcpy是不安全的，我们在使用时要保证其安全性
6、学会模拟实现。

char* My_strcpy(char* dest,const char* src)
{
    assert(dest&&src);
    char *ret=dest;
    while(*dest++=*src++)
    {
        ;
    }
}
int main()
{
    char arr1[]="xxxxxxxxxxxx";
    char arr2[]="abc";
    return 0;
}

strcat字符串连接或者字符串追加

strcat函数的介绍：

char * strcat ( char * destination, const char * source );
//原字符串追加到目的字符串的后面去
#include<ttdio.h>
#include<string.h>
int main()
{
    char arr1[20]="abc";
    //在字符串abc后面追加def。
    strcat(arr1,"def");
 }  

1、源字符串必须以 ‘\0’ 结束。如果源字符串没有’\0’追加将停不下来

2、会将源字符串中的 ‘\0’ 拷贝到目标空间。

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

4、目标空间必须可变。

5、学会模拟实现。

//strcat返回的是目标空间的起始地址
char* My_strcat(char* dest,const char* src)
{
    assert(dest&&src);
    char* ret=dest;
    //1.找到目标字符串的末尾'\0'
    while(*dest)
    {
        dest++;
    }
    //2.追加源字符串直到'\0'
    while( *dest++=*src++;)
    {
       ;
    }
    return ret;
}
int main()
{
    char arr1="abcf";
    My_strcat(arr1,"asd");
    char arr2="dadas";
    printf("%s\n",My_strcat(arr1,arr2));
    return 0;
}

strcmp字符串比较

strcmp函数介绍：
对于字符串的比较必须使用字符串比较函数。strcmp是比较字符串的，比较的是字符串的内容，不是长度。这个函数开始比较每个字符串的第一个字符。如果它们相等，它继续执行以下对，直到字符不相同或结束空字符时返回。

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

1、C语言标准规定的strcmp的返回值
1）str1<str2，返回小于0的整型
2）str2=str3，返回0
3）str1>str3，返回大于0的整型
2、在判定返回值时，除了0外其他不要写死，因为返回值是<0或者>0的
3、模拟实现strcmp

int My_strcmp(const char str1,const char str2)
{
//汉字在内存中是两个字节，如果比较汉字可能与你认为的逻辑有出入
//所以尽量不要使用strcmp比较汉字字符串
    assert(str1&&str2);
    while(*str1==*str2)
    {
        if(*str1=='\0')
        return 0;
        str1++;
        str2++;
    }
    return *str1-*str2;
}
int main()
{
    char arr1[]="abcq";
    char arr2[]="abc";
    My_strcmp(arr1,arr2);
}

注意：strcmp strcat strcmp这些函数是长度不受限制的字符串函数，所以安全性较低，所以后来引入了strncpy、strncat、strncmp等长度受限制的字符串函数，这些字符串函数是相对安全的。

strncpy指定长度的字符串拷贝

strncpy函数的介绍：

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

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

strncat指定长度的字符串最加

strncat函数的介绍：

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

1、将源字符串source里前num个字符追加到目标空间destionation，从目标空间的’\0’开始，并且在追加完成时，在尾部默认补上’\0’.

2、如果num大于源字符串里面的字符数量，会追加完整个源字符串再停止。所以在使用的时候要控制好数量，以免造成歧义。

strncmp指定字符串长度的比较

strncmp函数的介绍：

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

比较str1和str2的前num个字符，其余语法和strcmp相同

strstr字符串查找函数

strstr函数的介绍：

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

功能：在一个字符串里面查找子字符串是否存在，如果存在返回str1在str1里面第一次出现的那个位置，如果没有找到返回一个空指针。

int main()
{
    char arr1[]="i am good student hehe student";
    char arr2[]="student";
    //查找arr1中arr2第一次出现的位置，只返回第一个student中s的地址
    char *ret=strstr(arr1,arr2);
    if(ret==NULL)
    {
        printf("NO");
    }
    else
    {
        printf("%s",ret);//打印student hehe student
    }
}

模拟实现strstr函数：
strstr的工作有两种场景：1、一次匹配场景：在abcdef里找abc。2、多次匹配场景：在abbbcd里找bbc

char* My_strstr(const char* str1，const char* str2)
{
    assert(str1&&str2);
    if(*str2=='\0')
    {
        return str1;
    }
    char *s1;
    char *s2;
    char *head=str1;
    while(*head)
    {
        s1=head;
        s2=str2;
        while(*s1&&*s2&&*s1==*s2)
        {
            s1++;
            s2++;
        }
        if(*s2=='\0')
        {
            return head;
        }
        head++;
    }
    return NULL;
}
int main()
{
    char arr1[]="i am good student hehe student";
    char arr2[]="student";
    //查找arr1中arr2第一次出现的位置，只返回第一个student中s的地址
    char *ret=My_strstr(arr1,arr2);
    if(ret==NULL)
    {
        printf("NO");
    }
    else
    {
        printf("%s",ret);//打印student hehe student
    }
}

strtok切分字符串函数

strtok函数的介绍：

char* strtok(char* str,const char* sep);
char arr[20]="zja@bitedy.tech";
strtok(arr,"@.")

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

strerror错误信息报告函数

strerror函数的介绍：

#include<string.h>
char* strerror(int errnum);
返回错误码对应的信息：传一个错误码，返回的是错误码信息字符串的首地址。

注意：适用范围：仅仅适用于C语言库函数调用失败的时候。当库函数调用失败的时候，会把错误码，存在errno变量中。

memcpy内存拷贝函数

memcpy函数的介绍：

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

memcpy函数的介绍 原则是memcpy函数只完成不重叠的内存拷贝就可以了，就达到要求了

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

2、这个函数在遇到 ‘\0’ 的时候并不会停下来。

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

4、解决了strcpy只能拷贝字符串的单一性，可以拷贝整型,结构体等等
memcpy的使用示例：

int main()
{
   int arr1[10]={1,2,3,4,5,6,7,8,9,10};
   int arr2[20]={20};
   memcpy(arr2,arr1,sizeof(int)*10);
   
    return 0;
}

memmove可重叠的内存拷贝函数

memmove函数的介绍：

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

memmove函数包含了memcpy函数，原则是主要是重叠的内存拷贝，所以当源目标和目的空间重叠的时候要用memmove。把source起始的num个字节拷贝到destination里面去。

memcmp内存比较函数

memcmp函数的介绍：

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

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

2、memcmp函数的返回值：
1）ptr1<ptr2返回小于0的数字
2）ptr1=ptr2返回0
3）ptr1>ptr2返回大于0的数字
3、可以比较任何类型的数据，指定比较的数量，遇到\0不会停止