C語言之模拟字元和字元串操作函數

• 求字元串長度

.模拟實作strlen

//1
int mystrlen(const char *str)
{
    int count = ;
    while (*str)
    {
        count++;
        str++;
    }
    return count;
}
//2
int mystrlen(const char *str)
{
    if (*str == '\0')
    {
        return ;
    }
    else
        return  + mystrlen(str + );
}
//3
int mystrlen(const char *str)
{
    char *p = str;
    while (*p != '\0')
    {
        p++;
    }
    return p - str;
}
int main()
{
    char a[] = "abnfxbbfy";
    printf("%d\n", mystrlen(a));
    system("pause");
    return ;
}
           

• 長度不受限制的字元串操作函數

1.模拟實作strcpy ：複制字元串

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char* mystrcpy(char* dest, const char* str)
{
    char*ret = dest;
    assert(dest != NULL);
    assert(str != NULL);
    while (*dest++= *str++)
    {
        ;

    }
    return ret;
}
int main()
{
    char a[] = "abcdefh";
    char b[] = "gvbdgn";
    printf("%s\n",mystrcpy(a, b));
    system("pause");
    return ;
}
           

2.模拟實作strcat ：把一個字元串添加(連接配接)到另一個字元串的後面

char* mystrcat(char*dest, const char * src)
{
    char* ret = dest;
    assert(dest);
    assert(src);
    while (*dest)
    {
        dest++;
    }
    while (*dest = *src)
    {
        dest++,src++;
    }
    return ret;
}
int main()
{
    char a[] = "abcdefh";
    char b[] = "bun89";
    printf("%s\n",mystrcat(a, b));
    system("pause");
    return ;
}
           

3.模拟實作strcmp：比較兩個字元串

int my_strcmp(const char* str, const char *str1)
{
    assert(str);
    assert(str1);
    int ret = ;
    while (!(ret = *(unsigned char *)str - *(unsigned char *)str1)&&*str1)//檢測倆個字元串是否相等
    {
        ++str, ++str1;
    }
    if (ret < )
    {
        ret = -;
    }
    else if (ret>)
    {
        ret = ;
    }
    return ret;


}
int main()
{
    const char *str = "hgndhbdd";
    const char *str1 = "fhvcdd";
    int tmp = my_strcmp(str, str1);
    printf("%d\n", tmp);
    system("pause");
    return ;
}
           

• . 長度受限制的字元串函數

  1.模拟實作strncpy: 和strcpy一樣，strncpy把源字元串的字元複制到目标空間，但是，它總是正好向dest中拷貝len個字元

char* my_strncpy(char *dest, const char *src, int count)
{
    char *cp = dest;
    assert(src && dest);
    while (count && (*dest++ = *src++))
    {
        count--;
    }
    if (count>)
    {
        while (--count)
        {
            *dest++ = '\0';
        }
    }
    return cp;
}

int main()
{
    char a[] = "abcdefh";
    char b[] = "gvbsgze";
    printf("%s\n", my_strncpy(a, b,));
    system("pause");
    return ;
}
           

2.模拟實作strncat:它從src中最多複制len個字元到目标數組的後面

char* mystrncat(char*dest, const char * src,size_t num)
{
    char* ret = dest;
    assert(dest);
    assert(src);
    while (*dest)
    {
        dest++;
    }
    while (num--)
    {
        *dest = *src;
        dest++, src++;
    }
    return ret;
}
int main()
{
    char a[] = "abcdefh";
    char b[] = "bun89arg";
    printf("%s\n", mystrncat(a, b,));
    system("pause");
    return ;
}
           

3.模拟實作strncmp:用于比較兩個字元串，但它最多比較num個位元組

int my_strncmp(const char* str, const char *str1, size_t num)
{
    assert(str);
    assert(str1);
    int ret = ;
    while (num)
    {
        ret = *(unsigned char*)str - *(unsigned char*)str1;
        {
            ++str, ++str1;
        }
        if (ret < )
        {
            ret = -;
        }
        else if (ret>)
        {
            ret = ;
        }
        return ret;
    }
}
int main()
{
    const char *str = "nyfvdd";
    const char *str1 = "fhvcdd";
    int tmp = my_strncmp(str, str1,);
    printf("%d\n", tmp);
    system("pause");
    return ;
}
           

• 字元串查找函數

1.模拟實作strstr：在一個字元串中查找一個子串

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char *my_strstr(const char*str, const char* sub_str)
{
    assert(str);
    assert(sub_str);
    char *p = NULL;
    char *q = NULL;
    char *np = NULL;
    p = str;
    while (*p)
    {
        np = p;
        q = sub_str;
        for (; *np&&*q && *np == *q; np++, q++)
        {

        }
        if (*q == '\0')
        {
            return p;
        }
        if (*np == '\0')//str中沒有sub_str 
        {
            break;
        }
        p++;
    }
    return NULL;

}
int main()
{
    const char* src = "abbbcedf";
    const char* dest = "bce";
    char *ret = my_strstr(src, dest);
    printf("%s\n", ret);
    system("pause");
    return ;
}
           

• 記憶體操作函數

1.模拟實作memcpy：從源src所指的記憶體位址的起始位置開始拷貝num個位元組到目标dst所指的記憶體位址的起始位置中

void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest);
    assert(src);
    void* p = dest;
    while (num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + ;
        src = (char*)src + ;
    }
    return p;
}

int main()
{
    char dest[];
    char src[] = "abcb  buxdjbcxzy";
    printf("%s\n", my_memcpy(dest, src+, strlen(src) + ));
    system("pause");
    return ;
}
           

2.模拟實作memmove: 用于從src拷貝size個字元到dst，如果目标區域和源區域有重疊的話，memmove能夠保證源串在被覆寫之前将重疊區域的位元組拷貝到目标區域中。但複制後src内容會被更改。但是當目标區域與源區域沒有重疊則和memcpy函數功能相同。

void * mymemmove(void* dest, const void* str, size_t num)
{
    assert(dest);
    assert(str);
    void* ret = dest;
    if (dest > str && (char *)dest < (char *)str + num)
    {
        dest = (char *)dest + num - ;
        str = (char *)str + num - ;
        while (num--)
        {
            *(char *)dest = *(char *)str;
            dest = (char *)dest - ;
            str = (char *)str - ;
        }
    }
    else
    {
        while (num--)
        {
            *(char *)dest = *(char *)str;
            dest = (char *)dest + ;
            str = (char *)str +;
        }

    }
    return ret;
}
int main()
{
    char str[] = "abcde";
    mymemmove(str+, str, strlen(str) + );
    printf("%s\n", str);
    system("pause");
    return ;
}