c---字符串操作的实现（strcmp，strcpy，strstr，strchr，memmove，memcpy）

字符串操作的实现

---

   这两天在复习c语言部分，练习了一些有关于字符串的操作题，自己实现strcmp，strcpy，strstr，strchr，memmove，memcpy（后两个是对内存的操作）

---

一. strcmp

strcmp是用于比较两个字符串的大小的。

int strcmp( const char *string1, const char *string2 )
char *string1 = "abcd";
char *string2 = "abfdhjt";

   就像上面两个字符串，strcmp是从第一个字符开始比较，若是相同，就往后走一个字符，直到找到两个不同的字符或者有一个字符串已经结束，遇到了 ‘\0’ ，若是碰到了两个不同的元素，就比较这两个字符的大小，若是str1>str2，就返回正数，要是str1

int my_strcmp(const char *dst,const char *src)
{
    const char *d = dst;
    const char *s = src;
    while(*s != '\0' && *d != '\0')
    {
        if(*s > *d)
            return -1;
        else if(*d < *s)
            return 1;
        else if(*d == *s)
        {
            d++;
            s++;
        }
    }
    if(*s == '\0'&& *d == '\0')
        return 0;
    else if(*d == '\0')
        return -1;
    else
        return 1;
}

二. strcpy

   strcpy是用来复制字符串的，将源字符串（包括 ‘\0’ ）复制到目标字符串中，前提是得保证目标字符串有足够的空间去接收源字符串。

char *strcpy( char *strDestination, const char *strSource )

char *my_strcpy(char *dst,const char *src)
{
    if(dst == NULL || src == NULL)
        return NULL;
     const char *s = src;
    char *d = dst;
    while(*s != '\0')
    {
        *d = *s;
        d++;s++;
    }
    *d = '\0';
    return dst;
}

三. strstr

char *strstr( const char *string, const char *strCharSet );

   strstr是用于查找字符串当中的字串的，在string中查找是否存在strCharSet字串。若存在则返回在string中出现strCharSet的第一个字符的地址，若在string中不存在strCharSet字串，则返回NULL。

const char *my_strstr(const char *dst, const char *src)
{
    assert(dst);
    assert(src);
    const char *s = src;
    const char *d = dst;
    while(*d != '\0')
    {
        const char *ret;
        ret = d;
        s = src;
        while(*s != '\0' && *s == *d)
        {
            s++;
            d++;
        }
        if(*s == '\0')
            return ret;
        d++;
    }
    return NULL;
}

四. strchr

char *strchr( const char *string, int c )

   strchr是用来查找字符的，在目标字符串中是否有字符ch出现，若找到则返回第一次出现的地址，若没有找到，则返回NULL。

const char *my_strchr(const char *dst, int c)
{
    if(NULL == dst)
        return NULL;
    const char *d = dst;
    while(*d != '\0')
    {
        if(*d == c)
            return d;
        else 
            d++;
    }
    return NULL;
}

下面两个就有一点复杂，与string有些不同。他们是对内存进行操作的，以字节为单位进行复制。他们两个在某些情况下是有相同的功能的，但是还是有不一样的地方。memcpy不考虑内存重叠的问题。就像下图②所示，这两个字符串有内存重叠的地方，若是不考虑的话，直接从前往后复制的时候，会将后面还没有复制的地方改变，从而改变了还未进行复制的src串。就会导致拷贝的结果出错，最后得到的不是预期要的。图①的情况就适用于从后向前拷贝，所以在复制拷贝时需要判断是否出现了内存重叠的问题。

五. memcpy

void *memcpy( void *dest, const void *src, size_t count );

   memcpy没有考虑内存重叠的问题，它就是单纯的从前向后拷贝。

void *my_memcpy(void *dst, const void *src,size_t size)
{
    if(dst == NULL || src == NULL)
        return NULL;
    char *d =(char *) dst;
    char *s =(char *) src;
    while(size --)
    {
        *d++ = *s++;
    }
    return dst;
}

六. memmove

void *memmove( void *dest, const void *src, size_t count )

   memmove考虑了内存重叠的问题，进行了判断，若是src大于dst，就从后向前拷贝，若是src小于dst，就从前向后拷贝。

void *my_memmove(void *dst,const void *src,size_t size)
{
    if(NULL == dst || NULL == src)
        return NULL;
    char *d = (char *)dst;
    const char *s =(char *)src;
    int i = 0;
    if(d < s)
    {
        for(; i < (int)size;i++)
        {
            *d++ = *s++;
        }
    }
    else if(d >= s)
    {
        for(i = (int)size - 1; i >= 0; i--)
        {
            *(d + i) = *(s + i);
        }
    }
    return dst;
}