C语言字符串函数和内存函数模拟实现

Strlen的使用和模拟实现

使用：

 size_t strlen ( const char * str );

1. 字符串‘\0’作为结束标志，strlen函数返回的是字符串‘\0’前面出现的字符个数（不含括‘\0’）。
2. 参数指向的字符串必须要以‘\0’结束。
3. 注意函数的返回值为size_t，是无符号的
4. strlen的使用需要包含头文件

模拟实现

//方法一
int my_strlen(const char * str)
{
    int count = 0;
    assert(str);
    while(*str)
    {
        count++;
        str++;
    }
    return count;
}

//方法二
int my_strlen(const char * str)
{
    assert(str);
    if(*str == '\0')
        return 0;
    else
        return 1+my_strlen(str+1);
}

Strcpy的使用和模拟实现

使用

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

1. 源字符串必须以‘\0’结束。
2. 会将源字符串中的‘\0’拷贝到目标空间。
3. 目标空间必须足够大，确保能存放源字符串。且必须可以修改。

模拟实现

char *my_strcpy(char *dest, const char*src)
{
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

Stract的使用和模拟实现

使用

char *strcat( char *strDestination, const char *strSource );

1. 源字符串必须以‘\0’结束。
2. 目标字符串也得有\0，否则没办法追加从哪里开始。
3. 目标空间必须足够大，确保能存放源字符串。且必须可以修改。

模拟实现

char *my_strcat(char *dest, const char*src)
{
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while(*dest)
    {
        dest++;
    }
    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

Strcmp的使用和模拟实现

使用

int strcmp( const char *string1, const char *string2 );

1.  第一个字符串大于第二个字符串，则返回大于0。

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

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

模拟实现

int my_strcmp (const char * str1, const char * str2)
{
    int ret = 0 ;
    assert(src != NULL);
    assert(dest != NULL);
    while(*str1 == *str2)
    {
        if(*str1 == '\0')
            return 0;
        str1++;
        str2++;
    }
    return *str1-*str2;
}

Strrstr的使用和模拟实现 

使用

char * strstr ( const char * str1, const char * str2);
/*example*/
#include <stdio.h>
#include <string.h>
int main ()
{
    char str[] ="This is a simple string";
    char * pch;
    pch = strstr (str,"simple");
    strncpy (pch,"sample",6);
    printf("%s\n", str);
    return 0;
}

模拟实现 

char * strstr (const char * str1, const char * str2)
{
    char *cp = (char *) str1;
    char *s1, *s2;
    if ( !*str2 )
    return((char *)str1);
    while (*cp)
    {
        s1 = cp;
        s2 = (char *) str2;
        while ( *s1 && *s2 && !(*s1-*s2) )
                    s1++, s2++;
        if (!*s2)
                return(cp);
        cp++;
    }
    return(NULL);
}

 内存函数的使用和模拟实现

memcpy使用和模拟实现

使用

void * memcpy ( void * destination, const void * source, size_t num );
/*example*/
#include <stdio.h>
#include <string.h>
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[10] = { 0 };
    memcpy(arr2, arr1, 20);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

1. 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
2. 这个函数在遇到‘\0’的时候并不会停下来。
3. 如果source和destination有任何的重叠，复制的结果都是未定义的。

模拟实现

void * memcpy ( void * dst, const void * src, size_t count)
{
    void * ret = dst;
    assert(dst);
    assert(src);
    while (count--) 
    {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
    }
    return(ret);
}

 memove使用和模拟实现

使用

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

1. 和memcpy的差别就是memove函数处理的源内存块和目标内存块是可以重叠的。
2. 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟实现 

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