库函数的模拟实现

一.strcpy字符拷贝

1.形式：     char * strcpy(char * destination, const char * source)

2.条件：   （1） 源字符必须包含\0.

                 （2）会将源字符的\0拷贝到目标空间

                 （3）目标空间必须足够大，以确保能够存放源字符串

                 （4） 目标空间必须可以修改（不能是“abcd”这样的常量字符串）

3.使用程序

使用该函数可使arr2中的内容连带\0拷贝到arr1中。

int main()
{
    char arr1[50] = { 0 };
    char arr2[ ] = "hello";
    strcpy(arr1, arr2);
    printf("%s", arr1);
    return 0;
}

4.模拟实现

void my_strcpy(char*dest,char*src)
{
    while(*src!='\0')
    {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = *src;
}
int main()
{
    char arr1[20] = { 0 };
    char arr2[] = "abcde";
    my_strcpy(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

二.strcat追加字符串

1.形式：     char * strcat(char * destination, const char * source)

2.条件：    （1）  源字符必须以\0结束

                  （2）  目标字符串也得有\0否则没法知道追加从哪里开始

                  （3） 目标空间必须足够大，能容纳下源字符串内容

                  （4） 目标空间必须可修改

3.使用程序

使用该函数可将arr2的内容拷贝到arr1的\0之后

int main()
{
    char arr1[20] = "hello";
    char arr2[] = "world";
    strcat(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

4.模拟实现

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

}
int main()
{
    char arr1[20] = "hello";
    char arr2[] = "world";
    char*ret=my_strcat(arr1, arr2);
    printf("%s\n",ret);
    return 0;
}

三.strtok字符串分割

1.形式：     char * strtok(char * str, const char * sep)

2.条件       （1）  sep参数指向一个字符串，定义了用作分割符的字符集合

                 （2）  第一个参数指定一个字符串，他包含了0个或多个sep中的分割标记

                 （3） strtok函数找到str中的下一个标记并将其用\0结尾，返回一个指向这个标记的指针（源字符串需拷贝）

                 （4）  strtok函数的第一个参数不为NULL函数将找到str中的第一个标记，strtok函数将保存他在字符串中的位置

                （5）   strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记

                 （6）  如果字符串中不存在更多的标记，则返回NULL指针

3.使用程序

int main()
{
    char arr[] = "192.168.6@111";
    char* sep = ".@";
    char* str = NULL;
    for(str=strtok(arr,sep);str!=NULL;str=strtok(NULL,sep))
    {
        printf("%s\n", str);
    }
    return 0;
}

四.memcpy 内存拷贝

1.形式：    void * memcpy(void * destination, const void * source，size_t num)

2.使用程序

将arr1内从4开始的内容拷贝到arr2，拷贝的大小为12个字节。

int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9 };
    int arr2[10] = { 0 };
    memcpy(arr2, arr1 + 3, 5 * sizeof(int));
    int i = 0;
    for(i=0;i<10;i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

3.模拟实现

#define _CRT_SECURE_NO_WARNINGS

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

五.memmove重叠空间拷贝

1.形式：    void * memmove(void * destination, const void * source，size_t num)

2.使用程序

int main()
{
    int arr2[] = { 1,2,3,4,5,6,7,8,9,0 };
    memmove(arr2+2, arr2, 16);
    return 0;
}

3.模拟实现

void*my_memmove(void*dest,const void*src,size_t num)
{
    void* ret = dest;
    if(dest<src)
    {while(num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    }
    else
    {while(num--)
    {
        *((char*)dest + num) = *((char*)src + num);
    }
    }
    return ret;
}
int main()
{
    int arr2[] = { 1,2,3,4,5,6,7,8,9,0 };
    my_memmove(arr2+2, arr2, 16);
    return 0;
}

六.memcmp内存比较

1.形式：    void * memcmp(const void * ptr1, const void * ptr2，size_t num)

2.使用程序

int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9 };
    int arr2[] = { 1,2,3,4,8 };
    int ret = memcmp(arr1, arr2, 17);
    printf("%d\n", ret);
    return 0;
}