memcpy、memmove、memset、memchr、memcmp、strstr詳解

第一部分　　綜述

memcpy、memmove、memset、memchr、memcmp都是C語言中的庫函數，在頭文件string.h中。memcpy和memmove的作用是拷貝一定長度的內存的內容，memset用于緩沖區的填充工作，memchr用于字符的查找工作，memcmp用于比較內存中緩沖區的大小。

?

第二部分?　　介紹

1、memcpy和memmove

memcpy()--拷貝內存內容

表頭文件：#include<string.h>或#include<cstring>

定義函數：void *memcpy(void *dst,const void *src,size_t n)

函數說明：memcpy用來拷貝src所指的內存內容前n個字節到dst所指的內存地址上。與strcpy不同的是，memcpy會完成的復制n個字節，不會遇到字符串結束'\0'而結束（strncpy待會驗證）。

返回值：返回指向dst的指針。

附加說明：指src和dst所指的內存區域不可重疊

重疊實例：

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
    int a[10] = {0};
    for (int i = 0; i < 10; i++)
        a[i] = i;
    memcpy(&a[4],a,sizeof(int)*6);
    //memmove(&a[4], a, sizeof(int) * 6);
    for (int i = 0; i < 10; i++)
        cout << a[i];
    getchar();
    return 0;
}

會輸出0123012301，但是vs會輸出和memmove一樣的結果0123012345，原因是對src進行了保護，不允許更改。

2、memmove（）--拷貝內存內容

表頭文件：#include<string.h>或#include<cstring>

定義函數：void* memmove(void* dst,const void* src,size_t n)

函數說明：memmove()與memcpy()一樣都是用來拷貝src所指的內存前n個字節到dst所指的內存上。

不同的是，當src和dest所指的內存區域重疊時，memmove仍然可以正確的處理，不過執行效率上會比memcpy略慢。

返回值：返回值指向dst的指針。附加說明：指針src和dst所指的內存區域可以重疊。

3、memset（）--設置內存內容

表頭文件：#include<memory.h> ?#include<string.h>

函數說明：memset是C的庫函數，將s所指向的某一塊內存中的前n個字節全部設置成ch制定的ASCII值，塊的大小由第三個參數制定，這個函數通常為新申請的內存做初始化工作。

定義函數：void* memset(void *s,int ch,size_t n)

函數解釋：將s中前n個字節用ch替換并返回s。

作用：在一段內存塊中填充某個給定的值，他是對較大的結構體或數組進行清零操作的一種最快方法。

返回值：指向s的指針

上面的例子可以改一下

    int a[10] = {0};
    memset(a,0,10);

4、memchr（）--查找內存內容

表頭文件：#include<string.h>

函數說明：從buf所指內存區的前count個字節查找字符ch，當第一次遇到字符ch時停止查找。如果成功，返回指向字符ch的指針；否則返回null

定義函數：extern void* memchr(const void* buf,int ch,size_t count)

代碼實現

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
    char a[] = "nihao jingliming";
    void *p;
    p = memchr(a,'j',sizeof(a));
    if (p)
        cout << "has found:" << *((char*)p) << endl;
    else
        cout << "not found" << endl;
    getchar();
    return 0;
}

5、memcmp（）--內存比較

表頭文件：#include <string.h>

函數原型：int memcmp(const void* buf1,const void* buf2,unsigned int count)

函數描述：比較buf1和buf2的前count個字節

返回值：當buf1<buf2時，返回值<0

　　　　當buf1==buf2時，返回值=0

　　　　當buf1>buf2時，返回值>0

函數說明：該函數是按字節進行比較的

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
    char a[] = "nihao jingliming"; 
    char b[] = "nihao xiaoming";
    int r=memcmp(a,b,strlen(a));
    if (r>0)
        cout << "a is big" << endl;
    else if (r < 0)
        cout << "b is big" << endl;
    else
        cout << "same" << endl;
    getchar();
    return 0;
}

?第三部分　　實現

memcpy和memmove

linux內核版

/**
 * memcpy - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * You should not use this function to access IO space, use memcpy_toio()
 * or memcpy_fromio() instead.
 */
void * memcpy(void * dest,const void *src,size_t count)
{
    char *tmp = (char *) dest, *s = (char *) src;
    while (count--)
        *tmp++ = *s++;
    return dest;
}

/* Normally compiler builtins are used, but sometimes the compiler calls out
   of line code. Based on asm-i386/string.h.
 */
#define _STRING_C
#include <linux/string.h>
#undef memmove
void *memmove(void * dest,const void *src,size_t count)
{
    if (dest < src) { 
        __inline_memcpy(dest,src,count);
    } else {
        char *p = (char *) dest + count;
        char *s = (char *) src + count;
        while (count--)
            *--p = *--s;
    }
    return dest;
} 

window版

void * __cdecl memcpy (void * dst, const void * src, size_t count)
{
        void * ret = dst;

        /*
         * copy from lower addresses to higher addresses
         */
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
        }

        return(ret);
}

void * __cdecl memmove (void * dst, const void * src, size_t count)
{
        void * ret = dst;

        if (dst <= src || (char *)dst >= ((char *)src + count)) {
                /*
                 * Non-Overlapping Buffers
                 * copy from lower addresses to higher addresses
                 */
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else {
                /*
                 * Overlapping Buffers
                 * copy from higher addresses to lower addresses
                 */
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;

                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
                }
        }

        return(ret);
}

windows寫的就是分析的更詳細，效率更快。

memset

void *(memset) (void *s,int c,size_t n)
{
    const unsigned char uc = c;
    unsigned char *su;
    for(su = s;0 < n;++su,--n)
        *su = uc;
    return s;
}

memchr

void *memchr (const void *ptr, int value, int num)
{
if (ptr == NULL)
{
perror("ptr");
return NULL;
}
char * p = (char *)ptr;
while (num--)
{
if (*p != (char)value)
p++;
else
return p;
}

return NULL;
}

memcmp

/*  因為類型可以為任意，所以形參應為void * 
 *  相等則返回0，否則不為0 
 */  
int my_memcmp(const void *s1,const void *s2,size_t count)  
{  
    int res = 0;  
    const unsigned char *p1 =(const unsigned char *)s1;//注意是unsigned char *  
    const unsigned char *p2 =(const unsigned char *)s2;   
    for(p1 ,p2;count > 0;p1++,p2++,count--)  
        if((res =*p1 - *p2) != 0)   //不相當則結束比較  
            break;  
    return res;  
}  

?ststr實現

char* strstr(const char *s1, const char *s2)  
{  
    int n;  
    if (*s2)  
    {  
        while (*s1)  
        {  
            for (n=0; *(s1 + n) == *(s2 + n); n++)  
            {  
                if (!*(s2 + n + 1))  
                    return (char *)s1;  
            }  
            s1++;  
        }  
        return NULL;  
    }  
    else  
        return (char *)s1;  
}  

?