关于一些常见的str函数的使用

strlen

函数原型

size_t strlen( const char *string );

作用：求一个字符串的长度遇到\0停止，返回一个无符号整形

模拟实现

#include<stdio.h>
int my_strlen(const char*str)
{
    int n=0;
    while(*str)
    {
        n++;
        str++;
    }
    return n;
}
int main()
{
    char arr[]="asdfg";
    printf("%d\n",my_strlen(arr));
    return 0;
}

strcpy

函数原型

char *strcpy（char *strDest，const char *strSrc）

作用：拷贝strsrc中内容到strdest中，遇到\0停止拷贝，并且把\0拷贝进去

模拟实现

char* my_strcpy(char* p1, const char* p2)
{
    char* p = p1;
    while (*p1++=*p2++)
    {
        
    }
    return p;
}

strcat

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

作用：字符串追加函数，追加arr1到arr上，从arr 中遇到的第一个\0开始追加,追加到arr1的\0停止

模拟实现

char* my_strcat(char* p1, const char* p2)
{
    char* p = p1;
    while (*p1)
    {
        p1++;
    }
    while (*p2)
    {
        *p1 = *p2;
        p1++;
        p2++;
    }
    *p1 = '\0';
    return p;
}

strcmp

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

作用：字符串比较函数，返回类型是int如果第一个大于第二个返回>0数字，相等返回0；

模拟实现

int my_strcmp(const char* p1, const char* p2)
{
    while (*p1 != *p2 && *p2&&*p1)
    {
        p1++;
        p2++;
    }
    return *p1 - *p2;
}

以上函数都是不受限制的容易溢出什么的，有一些安全的函数，如strncpy,strncmp,strncat，多了一个参数，代表修改的字节数目，安全。

strchar

作用：查找字符

strstr

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

作用：strstr(arr,arr1);在一个字符串中找第一个字符串出现的位置，返回值是char*；返回值如果是空指针就是找不到

char* my_strstr(const char* p1, const char* p2)
{
    char* pp2 = (char*)p2;
    while (*p1)
    {
        char* pp1 = (char*)p1;
        p2 = pp2;
        while (*p2)
        {
            if (*p2 != *pp1)
                break;
            p2++;
            pp1++;
        }
        if (*p2 == '\0')
            return (char*)p1;
        p1++;
    }
    return NULL;
}

strtok

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

函数内部有static,把一个变量改成静态的

strtok(char*p,const char*a)//用于切割分割字符串，a是一个存放要切割字符的数组，p的被切割的字符串

切一段后会把被切割的字符改成\0，然后 记录(用static静态的关键字) 下被切割的位置，返回切割的字符串，然后如果你传递的参数是NULL，

那么下一次切割使用的字符串就是上一次函数中间记录的字符串。

常见使用

char arr[] = "asd.ert*asd.as";
char* p;
for (p= strtok(arr, "*."); p != NULL; p = strtok(NULL, "*."))
{
printf("%s\n",p);
}

memcpy

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

作用：从sour拷贝num个字节到dest,不能处理重叠的重复拷贝

void* my_memcpy(void* p1, const void* p2,unsigned int n)
{
    void* ret = p1;
    char* a = (char*)p1;
    char* b = (char*)p2;
    while (n--)
    {
        *a++ = *b++;
    }
    return ret;
}

memmove

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

作用：从source拷贝num个字节到dest可以处理重叠的拷贝

void* my_memmove(void* dst, const void* src, size_t n)
{
    void* ret = dst;
    char* p1 = (char*)dst;
    char* p2 = (char*)src;
    while (n--)
    {
        if (p1<=p2||p1>=p2+n)
        {
            *p1 = *p2;
            p1++;
            p2++;
        }
        else
        {
            *(p1 + n - 1) = *(p2 + n - 1);
        }
    }
    return ret;
}