模拟实现一些简单库函数

模拟实现一些简单的库函数

• strlen
• strcpy
• strcat
• strcmp
• strstr
• memcpy
• memmove

strlen的模拟实现

• strlen是用来求字符串长度，从首字符开始数，一直到'\0'才停下。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int my_strlen(const char* str)
{
    int count = 0;                //用count来记录字符个数
    assert(str);                  //判断指针不能为空
    while (*str != '\0')          
    {
        count++;
        str++;
    }
    return count;   
}
int main()
{
    char arr[] = "this is life";
    int ret = my_strlen(arr);
    printf("%d\n", ret);
    system("pause");
    return 0;
}

strcpy的模拟实现

• strcpy是用来拷贝字符串的，将源字符串拷到目标字符串，所以目标空间要保证足够大。

char *my_strcpy(char *dest, const char *src)
{
    char *ret = dest;                    //记录目标字符串的起始地址
    assert(dest && src);                 //判断指针不能为空
    while (*src != '\0')  
    {
        *dest = *src; 
        src++;
        dest++;
    }
    *dest = '\0';                       //将'\0'拷贝过去
    return ret;
}
int main()
{
    char arr1[20] = "aaaaaaaaaaaa";
    char arr2[] = "world";
    printf("%s\n", my_strcpy(arr1, arr2));
    system("pause");
    return 0；
}

strcat的模拟实现

• strcat是用来连接字符串的，将源字符串连接到目标字符串中，找到源字符串的’\0’，然后挨着往后拷贝，所以要保证目标空间足够大。

char *my_strcat(char *dest, const char *src)
{
    char *ret = dest;              //保存目标字符串起始地址
    assert(dest && src);            //判断指针有效性
    while (*dest != '\0')          //寻找目标字符串'\0'
    {
        dest++;
    }
    while (*dest++ = *src++)       //从目标字符串'\0'处开始往后拷贝
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[20] = "hello";
    char arr2[] = " world";
    printf("%s\n", my_strcat(arr1, arr2));
    system("pause");
    return 0;
}

strcmp的模拟实现

• strcmp是用来比较字符大小的，如果相等，返回0；如果第一个字符大于第二个字符，返回1；如果小于，则返回-1.

int my_strcmp(const char *p1, const char *p2)
{
    assert(p1 && p2);               //判断指针有效性
    while (*p1 == *p2)              //找不同元素
    {
        if (*p1 == '\0')            //如果相等，返回0；
            return 0;
        p1++;
        p2++;
    }
    if (*p1 > *p2)                  //如果第一个字符大于第二个字符，返回1；
        return 1;
    else                            //如果第一个字符小于第二个字符，返回-1
        return -1; 
}
int main()
{
    char *p1 = "abcd";
    char *p2 = "abc";
    printf("%d\n", my_strcmp);
    system("pause");
    return 0;
}

strstr的模拟实现

• strstr是用来在一个字符串中寻找字符串的，如果找到，则返回它在字符串的起始位置。

char *my_strstr(const char *str, const char *substr)
{         
    const char *s1 = str;               //用于在父字符串上移动 
    const char *s2 = substr;            //用于在子字符串上移动
    const char *cur = str;              //记录寻找子串的起始位置
    assert(str && substr);              //判断指针有效性
    while(*cur)                         //循环到父字符串结束
    {
        s1 = cur;                       //记录每次子串在父串的位置
        while ((*s1 == *s2) && (*s1 != '\0') && (*s2 != '\0'))
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')                //寻找到子串
            return cur;
        cur++;                          
    }
    return NULL;                        //找不到返回为空
}
int main()
{
    char *p1 = "abbbcde";
    char *p2 = "bbc";
    printf("%s\n", my_strstr(p1, p2));
    system("pause");
    return 0;
}

memcpy的模拟实现

• memcpy和strcpy都是可以拷贝字符串的,但两者有所差异，strcpy把字符串全部拷进去（包括’\0’），memcpy把指定的字节拷过去，所以它可以可字符型的，也可以拷贝整形的。

void *my_memcpy(void *dest, const void *src, size_t count)
{
    void *ret = dest;              //用来记录目标串的起始地址
    assert(dest && src);           //判断指针有效性
    while (count--)                //用count来控制拷贝的字节数
    {
        *(char *)dest = *(char *)src;
        src = (char *)src + 1;
        dest = (char *)dest + 1;
    }
    return ret;
}
int main()
{
    int arr1[] = { 1,2,3,4,5,6 };
    int arr2[] = { 7,8,9,0 };
    //char arr1[20] = "aaaaaaaa";
    //char arr2[] = "edrf";
    my_memcpy(arr1, arr2, 12);
    system("pause");
    return 0;
}

memmove的模拟实现

• memmove是用来拷贝重叠的元素，思想和memcpy一样，只是在拷贝的时候要分清楚从前向后拷贝，还是从后向前拷贝。

void *my_memmove(void *dest, const void *src, size_t count)
{
    void *ret = dest;              //保存目标地址
    assert(dest && src);           //判断指针有效性
    if (dest < src)                
    {
        while (count--)
        {
            *(char *)dest = *(char *)src;
            src = (char *)src + 1;
            dest = (char *)dest + 1;
        }
    }
    else
    {
        while (count--)
        {
            *((char *)dest + count) = *((char *)src + count);
        }
    }
    return ret;
}
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8 };
    my_memmove(arr1, arr1 + 2, 16);
    system("pause");
    return 0;
}