C语言之模拟字符和字符串操作函数

• 求字符串长度

.模拟实现strlen

//1
int mystrlen(const char *str)
{
    int count = 0;
    while (*str)
    {
        count++;
        str++;
    }
    return count;
}
//2
int mystrlen(const char *str)
{
    if (*str == '\0')
    {
        return 0;
    }
    else
        return 1 + mystrlen(str + 1);
}
//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 0;
}

---

• 长度不受限制的字符串操作函数

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 0;
}

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[15] = "abcdefh";
    char b[] = "bun89";
    printf("%s\n",mystrcat(a, b));
    system("pause");
    return 0;
}

3.模拟实现strcmp：比较两个字符串

int my_strcmp(const char* str, const char *str1)
{
    assert(str);
    assert(str1);
    int ret = 0;
    while (!(ret = *(unsigned char *)str - *(unsigned char *)str1)&&*str1)//检测俩个字符串是否相等
    {
        ++str, ++str1;
    }
    if (ret < 0)
    {
        ret = -1;
    }
    else if (ret>0)
    {
        ret = 1;
    }
    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 0;
}

---

• . 长度受限制的字符串函数
  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>0)
    {
        while (--count)
        {
            *dest++ = '\0';
        }
    }
    return cp;
}

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

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[20] = "abcdefh";
    char b[] = "bun89arg";
    printf("%s\n", mystrncat(a, b,4));
    system("pause");
    return 0;
}

3.模拟实现strncmp:用于比较两个字符串，但它最多比较num个字节

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

---

• 字符串查找函数

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 0;
}

---

• 内存操作函数

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 + 1;
        src = (char*)src + 1;
    }
    return p;
}

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

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 - 1;
        str = (char *)str + num - 1;
        while (num--)
        {
            *(char *)dest = *(char *)str;
            dest = (char *)dest - 1;
            str = (char *)str - 1;
        }
    }
    else
    {
        while (num--)
        {
            *(char *)dest = *(char *)str;
            dest = (char *)dest + 1;
            str = (char *)str +1;
        }

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