【C語言】 字符串操作函數及內存拷貝函數歸總

今天在這裏把零散的一些常用的字符串操作函數和內存拷貝函數進行一下歸總實現。

一 . 字符串操作函數

字符串操作函數有很多，這裏我列舉一些常用的函數，以及自實現的代碼：

字符串拷貝函數：

函數原型：

char* my_strcpy(char* dst,const char* src)

strcpy()：

char* my_strcpy(char* dst,const char* src)
{
    assert(dst);
    assert(src);

    char *ret = dst;  //把首地址保存起來，因爲下面會修改dst
    while (*dst++ = *src++)
        ;

    return ret;
}

函數原型：

char* my_strncpy(char* dst,const char* src,int n)

strncpy()：

char* my_strncpy(char* dst,const char* src,int n)
{
    assert(dst);
    assert(src);

    char* ret = dst;
    while (n--)
    {
        *dst++ = *src++;
    }

    return ret;
}

字符串追加函數：

函數原型：

char* my_strcat(char* dst,const char* src)

strcat()：

char* my_strcat(char* dst,const char* src)
{
    assert(dst);
    assert(src);

    char *ret = dst;

    while (*dst) 
        dst++;

    while (*dst++ = *src++)
        ;

    return ret;
}

函數原型：

char* my_strncat(char *dst, const char *src, int n)

strncat()：

char* my_strncat(char *dst, const char *src, int n)
{
    assert(dst);
    assert(src);

    char *ret = dst;
    while (*dst)
        dst++;
    while (n--)
    {
        *dst++ = *src++;
    }

    return ret;
}

字符串比較函數：

函數原型：

int my_strcmp(const char* dst,const char* src)

strcmp()：

int my_strcmp(const char* dst,const char* src)
{
    assert(dst);
    assert(src);

    while ((*dst == *src) && *dst && *src)
    {
        dst++;
        src++;
        if (*dst == 0 && *src == 0)
        {
            return 1;
        }
    }

    return -1;
}

函數原型：

int my_strncmp(char* dst, const char* src, int n)

strncmp()：

int my_strncmp(char* dst, const char* src, int n)
{
    assert(dst);
    assert(src);

    while (n--)
    {
        if ((*dst == *src) && *dst && *src)
        {
            dst++;
            src++;
        }
        else
        {
            return -1;
        }

        if (*dst == 0 && *src == 0) // 全部相同時的處理情況
        {
            return 1;
        }
    }    

    return 1; // 部分相同時的處理情況
}

查找子字符串函數：

函數原型：

char* my_strtsr(char* str1, char* str2)

strstr()：

char* my_strtsr(char* str1, char* str2)
{
    assert(str1); // 原串
    assert(str2); // 子串

    char* s1 = str1;
    char* s2 = str2;
    char* s = str2; // 保存子串的首地址

    if (*s1 == 0)
    {
        if (*s2)
            return NULL;

        return s;
    }

    while (*s1 && *s2)
    {
        if (*s1 != *s2)
        {
            s1++;
        }
        if (*s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s1 != *s2) 
        {
            if (*s1 == 0)
            {
                return NULL;
            }
            else if (*s2 == 0)
            {
                return s;
            }

            s2 = s; //若*s1和s2不相等，則讓子串重新從頭開始
        }    
    }

    return NULL;
}

---

---

二 . 內存拷貝函數

內存拷貝函數這裏羅列出 memcpy() 以及解決內存拷貝時重疊的問題的函數 memmove() ，附帶寫出內存初始化函數memset() .

內存拷貝函數：

函數原型：

void* my_memcpy(void *dt,const void *src,size_t count)

memcpy()：

void* my_memcpy(void *dst,const void *src,size_t count)
{
    assert(dst);
    assert(src);

    char *pDst = (char*)dst;
    char *pSrc = (char*)src;
    char *ret = (char*)dst; // 保存dst首地址

    while (count--)
    {
        *pDst++ = *pSrc++;
    }

    return ret;
}

解決內存拷貝時 的內存重疊問題的函數：

函數原型：

void* my_memmove(void *p1,void *p2,size_t count)

memmove()：

void* my_memmove(void *p1,void *p2,size_t count)
{
    // 在一個數組中進行
    assert(p1);
    assert(p2);

    char *dst = (char*)p1;
    char *src = (char*)p2;
    char *ret = (char*)p1; // 保存首地址

    if (dst > src && (dst < src + count)) // 判斷內存重疊情況
    {
        while (count--)
        {
            *(dst + count) = *(src + count);
        }
    }
    else // 不重疊情況
    {
        while (count--)
        {
            *dst++ = *src++;
        }
    }

    return ret;
}

內存初始化函數：

函數原型：

void* my_memset(void* arr,int c,size_t size)

memset()：

void* my_memset(void* arr,int c,size_t size)
{
    assert(arr);

    char* dst = (char*)arr;
    int i = 0;
    for (i = 0; i < size; i++)
    {
        *(dst + i) = c;
    }

    return arr;
}

附源代碼及測試代碼：

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

char* my_strcpy(char* dst,const char* src)
{
    assert(dst);
    assert(src);

    char *ret = dst;  //把首地址保存起來，因爲下面會修改dst
    while (*dst++ = *src++)
        ;

    return ret;
}

char* my_strncpy(char* dst,const char* src,int n)
{
    assert(dst);
    assert(src);

    char* ret = dst;
    while (n--)
    {
        *dst++ = *src++;
    }

    return ret;
}


char* my_strcat(char* dst,const char* src)
{
    assert(dst);
    assert(src);

    char *ret = dst;

    while (*dst) 
        dst++;

    while (*dst++ = *src++)
        ;

    return ret;
}

char* my_strncat(char *dst, const char *src, int n)
{
    assert(dst);
    assert(src);

    char *ret = dst;
    while (*dst)
        dst++;
    while (n--)
    {
        *dst++ = *src++;
    }

    return ret;
}

int my_strcmp(const char* dst,const char* src)
{
    assert(dst);
    assert(src);

    while ((*dst == *src) && *dst && *src)
    {
        dst++;
        src++;
        if (*dst == 0 && *src == 0)
        {
            return 1;
        }
    }

    return -1;
}

int my_strncmp(char* dst, const char* src, int n)
{
    assert(dst);
    assert(src);

    while (n--)
    {
        if ((*dst == *src) && *dst && *src)
        {
            dst++;
            src++;
        }
        else
        {
            return -1;
        }

        if (*dst == 0 && *src == 0) // 全部相同時的處理情況
        {
            return 1;
        }
    }    

    return 1; // 部分相同時的處理情況
}

char* my_strtsr(char* str1, char* str2)
{
    assert(str1); // 原串
    assert(str2); // 子串

    char* s1 = str1;
    char* s2 = str2;
    char* s = str2; // 保存子串的首地址

    if (*s1 == 0)
    {
        if (*s2)
            return NULL;

        return s;
    }

    while (*s1 && *s2)
    {
        if (*s1 != *s2)
        {
            s1++;
        }
        if (*s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s1 != *s2)
        {
            if (*s1 == 0)
            {
                return NULL;
            }
            else if (*s2 == 0)
            {
                return s;
            }

            s2 = s;
        }    
    }

    return NULL;
}

void* my_memcpy(void *dst,const void *src,size_t count)
{
    assert(dst);
    assert(src);

    char *pDst = (char*)dst;
    char *pSrc = (char*)src;
    char *ret = (char*)dst; // 保存dst首地址

    while (count--)
    {
        *pDst++ = *pSrc++;
    }

    return ret;
}

void* my_memmove(void *p1,void *p2,size_t count)
{
    // 在一個數組中進行
    assert(p1);
    assert(p2);

    char *dst = (char*)p1;
    char *src = (char*)p2;
    char *ret = (char*)p1; // 保存首地址

    if (dst > src && (dst < src + count)) // 判斷內存重疊情況
    {
        while (count--)
        {
            *(dst + count) = *(src + count);
        }
    }
    else // 不重疊情況
    {
        while (count--)
        {
            *dst++ = *src++;
        }
    }

    return ret;
}

void* my_memset(void* arr,int c,size_t size)
{
    assert(arr);

    char* dst = (char*)arr;
    int i = 0;
    for (i = 0; i < size; i++)
    {
        *(dst + i) = c;
    }

    return arr;
}


void test1()
{
    char a1[10] = { 0 };
    char a2[] = "world";

    printf("%s", my_strcpy(a1, a2));
    printf("\n");
}

void test2()
{
    char a1[15] = "hello";
    char a2[] = " world";

    printf("%s",my_strcat(a1,a2));
    printf("\n");
}

void test3()
{
    char a1[] = "abcdef";
    char a2[] = "abcdef";
    printf("%d\n",my_strcmp(a1,a2));
}

void test4()
{
    char a1[10] = "hello";
    char a2[] = " world";

    printf("%s",my_strncat(a1,a2,4));
    printf("\n");
}

void test5()
{
    int a1[10] = {1,2,3,4,5,6,7,8,9,10};
    int a2[10];
    int i = 0;

    my_memcpy(a2,a1,4);
    for (i = 0; i < 10;i++)
    {
        printf("%d ", a2[i]);
    }
    printf("\n");
}

void test6()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;

    my_memmove(a+2,a+5,4);
    for (i = 0; i < 10;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
}

void test7()
{
    char a1[10] = { 0 };
    char a2[] = "world";

    printf("%s", my_strncpy(a1, a2, 3));
    printf("\n");
}

void test8()
{
    char a1[] = "abcdef";
    char a2[] = "acb";

    printf("%d\n", my_strncmp(a1, a2, 2));
}

void test9()
{
    char* a1 = "abccddefgh";
    char* a2 = "cddef";

    printf("%s",my_strtsr(a1,a2));
    printf("\n");
}

void test10()
{
    int arr[10];
    int i = 0;
    my_memset(arr, 0, 32);
    for (i = 0; i < 10; i++)
        printf("%d ",arr[i]);
    printf("\n");
}

int main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();
    test8();
    test9();
    test10();

    system("pause");
    return 0;
}

若有紕漏，歡迎指正。