string库函数中常见函数的模拟实现

1. my_strlen
模拟strlen函数，以’\0’为结尾，计算字符串中字符的个数，不含’\0’，返回值是size_t类型的无符号整型；

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

2. my_strcpy

这里是引用

模拟strcpy函数，把源字符串拷贝至目标空间，含源字符串的’\0’，拷贝过程以源字符串的’\0’为终点，目标空间可变，修改目标空间并返回目标空间的初始地址；

 char *my_strcpy(char *dest,const char *src)
{
    assert(dest&&src);
    char *s=dest;
    while(*src)
    {
        *s++=*src++;
    }
    *s=*src;
    return dest;
}

3. my_strcat
模拟strcat函数，把源字符串嫁接至目标字符串后端，含源字符串的’\0’，嫁接过程以源字符串的’\0’为终点，目标空间可变，修改目标空间并返回目标空间的初始地址；

 char *my_strcat(char *dest,const char *src)
{
    assert(dest&&src);
    char *s=dest;
    while(*s)
    {
        s++;
    }
    while(*src)
    {
        *s++=*src++;
    }
    *s=*src;
    return dest;
}

4. my_strcmp
模拟strcmp函数，从前往后比较两个字符串中对应序列字符的ASCII码值的大小，比较结果：

1. 比较过程中，第一个字符串的字符大于第二个字符串的对应字符，则返回大于零的整数；
2. 比较过程中，第一个字符串的字符小于第二个字符串的对应字符，则返回小于零的整数；
3. 比较过程中，第一个字符串的字符均等于第二个字符串的对应字符，且两个字符串长度相等，则返回0；
4. 比较过程中，第一个字符串的字符均等于第二个字符串的对应字符，但第一个字符串比第二个字符串长，比较结束后，返回第一个字符串比第二个字符串多出的那部份的第一个字符对应的ASCII码值；
5. 比较过程中，第一个字符串的字符均等于第二个字符串的对应字符，但第二个字符串比第一个字符串长，比较结束后，返回第二个字符串比第一个字符串多出的那部份的第一个字符对应的ASCII码值的相反数；

int my_strcmp(const char *str1,const char *str2)
{
    assert(*str1&&*str2);
    while(*str1&&*str2)
    {
        if(*str1>*str2)
        {
            return 1;
        }
        else if(*str1<*str2)
        {
            return -1;
        }
        str1++;
        str2++;
    }
    return *str1-*str2;
}

5. my_strncpy
模拟strncpy函数，从源字符串拷贝指定数目的字符至目标空间，若指定的数目大于源字符串的长度，则拷贝过程以源字符串的’\0’为终点，连同’\0’一起拷贝，目标空间可变，修改目标空间并返回目标空间的初始地址；

 char *my_strncpy(char *dest,const char *src,size_t len)
{
    assert(dest&&src);
    size_t l=0;
    char *s=dest;
    for(l=0;l<len;l++)
    {
        *s++=*src++;
        if(*src=='\0')
        {
            *s=*src;
            break;
        }
    }
    return dest;
}

6. my_strncat
模拟strncat函数，从源字符串嫁接指定数目的字符至目标字符串后端，若指定的数目大于源字符串的长度，则嫁接过程以源字符串的’\0’为终点，连同’\0’一起拷贝，目标空间可变，修改目标空间并返回目标空间的初始地址；

 char *my_strncat(char *dest,const char *src,size_t len)
{
    assert(dest&&src);
    char *s=dest;
    while(*s)
    {
        s++;
    }
    size_t l=0;
    for(l=0;l<len;l++)
    {
        *s++=*src++;
        if(*src=='\0')
        {
            *s=*src;
            break;
        }
    }
    return dest;
}

7. my_strncmp
模拟strncmp函数，根据指定的长度用strcmp函数的方式比较两个字符串，若指定的长度大于第二个字符串长度，则实现strcmp函数比较的完整过程；

 int my_strncmp(const char *str1,const char *str2,size_t len)
{
    size_t l=0;
    for(l=0;l<len;l++)
    {
        if(*str1&&*str2)
        {
            if(*str1>*str2)
            {
                return 1;
            }
            else if (*str1<*str2)
            {
                return -1;
            }
        }
        else
        {
            break;
        }
        str1++;
        str2++;
    }
    return *str1-*str2;
}

8. my_strstr
模拟strstr函数，从目标空间中寻找和源字符串一致的字段，若找到，则返回与源字符串第一个字符一致的目标空间的字符的地址，否则，返回空指针，目标字符串和源字符串均不可修改；

 const char* my_strstr(const char *dest,const char *src)
{
    while(*dest)
    {
        if(*dest==*src)
        {
            const char *s1=dest;
            const char *s2=src;
            while(*s1&&*s2)
            {
                if(*s1!=*s2)
                {
                    break;
                }
                s1++;
                s2++;
            }
            if(*s2=='\0')
            {
                return dest;
            }
            else if(*s1=='\0'&&*s2!='\0')
            {
                return NULL;
            }
        }
        dest++;
    }
    return NULL;
}

9. my_strtok
模拟strtok函数，根据源字符串中含有的字符寻找目标空间中一致的字符，并以此字符为断点分割目标字符串，返回值为目标字符串起点地址或断点地址，每调用一次，返回的断点地址前进一格，跳至目标字符串末尾时，返回空指针；

 char* my_strtok(char *str,const char *p)
{
    static char *s=NULL;
    if(str!=NULL)
    {
        s=str;
    }
    else
    {
        str=s;
    }
    if(*str=='\0')
    {
        return NULL;
    }
    char *s1=str;
    while(*s1)
    {
        const char *p1=p;
        while(*p1)
        {
            if(*s1==*p1)
            {
                break;
            }
            p1++;
        }
        if(*p1!='\0')
        {
            *s1='\0';
            s=s1+1;
            return str;
        }
        s1++;
    }
    s=s1;
    return str;
}

10. my_memcpy
模拟memcpy函数，把源内存的数据信息按照指定字节数拷贝至目标内存空间，修改目标内存空间并返回目标空间的初始地址；

void *my_memcpy(void *dest,const void *src,size_t len)
{
	assert(dest&&src);
    size_t l=0;
    char *d=(char*)dest;
    char *s1=(char*)malloc(sizeof(char)*len);
    char *s2=s1;
    for(l=0;l<len;l++)
    {
        *s1=*(char*)src;
        s1++;
        src=(char*)src+1;
    }
    for(l=0;l<len;l++)
    {
        *d++=*s2++;
    }
    return dest;
}

11. my_memmove
模拟memmove函数，功能同memcpy函数，代码同行；
12. my_memcmp
模拟memcmp函数，按照指定字节数对两个内存空间逐个字节比较大小，若在指定字节数范围内两段内存空间每个字节存储的信息ASCII码值均相同，则返回0，若在指定字节数范围内两段内存空间对应字节存储的信息有所不同，则返回第一对不同的字节对应的信息ASCII码差值，若指定的字节数大于其中一个内存空间，则返回比较过程结束时指针指向的较大的内存空间的字节单元的信息的ASCiI码值（若第二个内存空间较大，则返回值取反）；

 int my_memcmp(const void *str1,const void *str2,size_t len)
{
    assert(str1&&str2);
    char *s1=(char*)str1;
    char *s2=(char*)str2;
    size_t l=0;
    for(l=0;l<len;l++)
    {
        if(*s1!=*s2)
        {
            return *s1-*s2;
        }
        s1++;
        s2++;
    }
    return 0;
}