字符函数与字符串函数的模拟编译

只是根据对代码的初步理解而编译。虽然基本功能与原函数相似，

但函数内部真正的运行方式和逻辑并不像模拟的函数这么简单。

字符函数：

字符串函数：

                        strlen:

/*
#include <stdio.h>
#include <assert.h>
int my_strlen(const char* str)
{
    int count = 0;
    assert(str != NULL);
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}
int main()
{
    char arr[] = "abcdefg";
    int ret = my_strlen(arr);
    printf("%d\n", ret);
    return 0;
}
*/

                        strcpy:

/*
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
    assert(src && dest);
    char* ret = dest;
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[20] = { 0 };
    char arr2[] = "abcdef";
    //char* arr2 = "abcdef";
    my_strcpy(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}
*/

                        strcat:

/*
#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, char* src)
{
    assert(dest && src);
    char* ret = dest;
    while (*dest)//找'\0'
    {
        dest++;
    }
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char a1[20] = "Hello";
    char a2[] = "Bit";
    my_strcat(a1, a2);
    printf("%s\n", a1);
    return 0;
}
*/

                        strcmp:

/*
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* s1, const char* s2)
{
    assert(s1 && s2);
    while (*s1 == *s2)
    {
        if (*s1 == '\0')//相等
        {
            return 0;
        }
        s1++;
        s2++;
        if (*s1 > *s2)
            return 1;
        else
            return -1;
    }

}
int main()
{
    char a1[] = "abc";
    char a2[] = "acd";
    int ret = my_strcmp(a1, a2);
    if (ret > 0)
        printf(">\n");
    if (ret == 0)
        printf("=\n");
    if (ret < 0)
        printf("<\n");
    return 0;
}
*/

                        strncat:

                        strncpy:

                        strstncmp:

                        strstr:

/*
#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);
    const char* s1 = str1;
    const char* s2 = str2;
    const char* cur = str1;
    while (*cur)
    {
        s1 = cur;
        s2 = str2;

        while (*s1 && *s2 && (*s1 == *s2))
        {
            s1++;
            s2++;
        }

        if (*s2 == '\0')//找到了
        {
            return (char*)cur;
        }

        cur++;
    }
    return NULL;//找不到
}
int main()
{
    char a1[] = "abcdefabcdef";
    char a2[] = "cdef";
    char* ret = my_strstr(a1, a2);
    if (NULL == ret)
    {
        printf("找不到\n");
    }
    else
    {
        printf("%s\n", ret);
    }
    return 0;
}
*/

                        strtok:

char* strtok(char* str,const char* sep);

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

sep参数是个字符串，定义了用作分隔符的字符集合

strtok会找到str中的下一个标记，并将其用'\0'结尾，返回一个指向这个标记的指针

若str不为NULL：函数将找到第一个标记，并保存它在字符串中的位置

若str为NULL：函数将在同一字符串中被保存的位置开始，查找下一个标记

                        strerror:：

返回错误码所对应的错误信息

内存操作函数：

                        memcpy:

/*

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, void* src, size_t count)
{
    void* ret = dest;
    assert(dest && src);
    while (count--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    return ret;
}
int main()
{
    int a1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int a2[5] = { 0 };
    my_memcpy(a2, a1, 20);//一个数字4个字节
    for (int i = 0; i < 5; i++)
    {
        printf("%d ", a2[i]);
    }
    return 0;
}

*/

                        memmove:

/*
#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, void* src, size_t count)
{
    assert(dest && src);
    void* ret = dest;
    if (dest < src)
    {    //前-->后
        while (count--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else
    {    //后-->前
        while (count--)
        {
            *((char*)dest + count) = *((char*)src + count);
        }
    }
    return ret;
}
int main()
{
    int a1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    my_memmove(a1 + 2, a1 + 5, 20);//一个字母4个字节
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", a1[i]);
    }
    return 0;
}
*/

                        memcmp:

int memcmp(const void* ptr1, const void* ptr2,size_t num);

比较ptr1，ptr2指针开始的num个字节

                        memset:

void* memset(void*dest, int c, size_t count);

注意：操作是以字节为单位进行的，c是要变成的数字