mem函數源碼

mem函數源碼

1.memcpy函數

1. 原型：void *memcpy(void *dest, const void *src, int count)
2. 作用：由src指定內存區域拷貝count個字符到dest所指定的內存區域。
3. 代碼：

void *my_memcpy(void *dest, const void *src, int count)
{
    /*由src指定內存區域拷貝count個字符到dest所指定的內存區域。
    src和dest內存區域不能重疊，函數返回指向dest的指針。*/
    //拷貝完成不會自動加上'\0'
    unsigned char *p = (unsigned char *)dest;
    unsigned char *q = (unsigned char *)src;
    while(count--)
    {
        *p++ = *q++;
    }
    return dest;
}

int main()
{
    char a[20];
    char *p;
    p = (char *)my_memcpy(a, "hello world!", 12);
    *(p+12) = '\0';  //爲puts做準備
    puts(a);
    return 0;
}

2.memccpy函數

1. 原型：void *memccpy(void *dest, const void *src, char ch, int count)
2. 作用：如果src前n個字節中存在’ch’，返回指向字符’ch’後的第一個字符的指針；
   返回NULL，並且複製src。
3. 代碼：

#include <string.h>

void *my_memccpy(void *dest, const void *src, char ch, int count)
{
    /*如果src前n個字節中存在’ch’，返回指向字符’ch’後的第一個字符的指針；
    返回NULL，並且複製src。
    一個條件達到就結束*/
    //對於數字字符，遇見空格則停止，並返回指向空格的指針

    while(count--)
    {
        *(char *)dest = *(char *)src;
        dest = (char *)dest + 1;
        if(*(char *)src == (char)ch)
            break;
        src = (char *)src + 1;
    }
    return (count ? (char *)dest : NULL);
}

int main()
{
    char a[20];
    char *p;
    char *str ="hello world!";
    char ch;

    ch = '9';
    p = (char *)my_memccpy(a, str, ch, strlen(str)+1);
    if(p == NULL)
        printf("Can't not find character.\n");
    else
    {
        printf("Find the character! \n");
        *p= '\0';  //爲下面的puts函數準備
    }
    printf("The String which has been copied is:  ");
    puts(a);  //puts()從string的開頭往stdout中輸出字符，直到遇見結束標誌 '\0'，'\0'不會被輸出到stdout。

    printf("************************************");

    ch = 'b';
    p = (char *)my_memccpy(a, str, ch, strlen(str)+1);
    if(p == NULL)
        printf("Can't not find character.\n");
    else
    {
        printf("\nFind the character! \n");
        *p = '\0';
    }
    printf("The String which has been copied is:  ");
    puts(a);
    return 0;
}

3.memmove函數

1. 原型：void *memmove(void *dest, const void *src, int count)
2. 作用：由src所指定的內存區域賦值count個字符到dest所指定的內存區域。
   src和dest所指內存區域可以重疊
3. 代碼：

#include <string.h>

void * my_memmove(void *dest, const void *src, int count)
{
    /*由src所指定的內存區域賦值count個字符到dest所指定的內存區域。
    src和dest所指內存區域可以重疊，
    但複製後src的內容會被更改,最終函數返回指向dest的指針。*/
    //可以自己考慮count的大小，大於0，小於src的大小

    if((unsigned char *)dest >= ((unsigned char *)src + count))
    {
        /*若果沒有重疊*/
        dest = memcpy (dest, src, count);
    }
    else
    {
        /*如果有重疊,則從尾部進行拷貝*/
        unsigned char *p = (unsigned char *)dest + count;
        unsigned char *q = (unsigned char *)src + count;
        while (count--)
        {
            *--p = *--q;
        }
    }
    return dest;
}

int main()
{
    /*正常的複製*/
    char a[20];
    puts((char *)my_memmove(a, "hello world!", 16));

    /*內存重疊*/
    char str[] = "memmove can be very useful......";
    my_memmove (str+20, str+15, 11);
    puts (str);
    return 0;
}

4.memcmp函數

1. 原型：int memcmp(const void *buffer1, const void *buffer2, int count)
2. 作用：比較內存區域buffer1和buffer2的前count個字節。
3. 代碼：

int my_memcmp(const void *buffer1, const void *buffer2, int count)
{
    /*比較內存區域buffer1和buffer2的前count個字節。
    當buffer1 < buffer2時，返回值 < 0；
    當buffer1 = buffer2時，返回值 0；
    當buffer1 > buffer2時，返回值 > 0。*/

    if(!count)
        return 0;
    while(--count && *(char *)buffer1 == *(char *)buffer2)
    {
        //判斷前count個字符是否相等
        buffer1 = (char *)buffer1 + 1;
        buffer2 = (char *)buffer2 + 1;
    }
    //返回兩個字符串的首個字符的差值
    return ( *((unsigned char *)buffer1) - *((unsigned char *)buffer2) );
}

int main()
{
    char *str1 = "hello";
    char *str2 = "world";
    int n = 0;
    scanf("%d", &n);

    int res = my_memcmp(str1, str2, n);
    if(res > 0)
        printf("%s Upper Than %s\n", str1, str2);
    else if(res < 0)
        printf("%s Lower Than %s\n", str1, str2);
    else
        printf("%s Equal %s\n", str1, str2);

    return 0;
}

5.memchr函數

1. 原型：void *memchr(const void *buffer, int ch, int count)
2. 作用：從buffer所指內存區域的前count個字節查找字符ch，
   當第一次遇到字符ch時停止查找。
3. 代碼：

#include <string.h>

void * my_memchr(const void *buffer, int ch, int count)
{
    /*從buffer所指內存區域的前count個字節查找字符ch，
    當第一次遇到字符ch時停止查找。
    如果成功，返回指向字符ch的指針,否則返回NULL*/
    //對於數字字符，遇見空格則停止，並返回指向空格的指針

    while(count-- && (unsigned char)ch != *(unsigned char *)buffer)
    {
        buffer = (unsigned char *)buffer + 1;
    }
    return(count ? (void *)buffer : NULL);
}

int main()
{
    char *str = "hello world!";
    char *p;
    char ch;

    ch = '1';
    p = (char *)my_memchr(str, ch, strlen(str)+1);
    if(p == NULL)
        printf("Can't find the character %c !\n", ch);
    else
        printf("Find the character %c !\n", *p);

    ch = 'd';
    p = (char *)my_memchr(str ,ch, strlen(str)+1);
    if(p == NULL)
        printf("Can't find the character %c !\n", ch);
    else
        printf("Find the character %c !\n", *p);

    return 0;
}

參考文章

鏈接：
http://www.cnblogs.com/jiangyinglin/p/3247087.html