内存操作函数memcpy，memccpy，memmove，memchr，memcmp，memicmp，memset

(1)函数原型：extern void *memcpy(void *dest, void *src, unsigned int count);
参数说明：dest为目的字符串，src为源字符串，count为要拷贝的字节数。        
所在库名：#include <string.h>

函数功能：将字符串src中的前n个字节拷贝到dest中。

返回说明：src和dest所指内存区域不能重叠，函数返回void*指针。 //注意memcpy返回的是void*类型

Linux中：

1

2

3

4

5

6

7

8

9

10

void   *memcpy(void *dest, const void *src, size_t count)

{

assert(dest != NULL && src != NULL);

char *tmp = dest;    const char *s = src;

while (count--)

{

*tmp++ = *s++ ;

}

return dest;

}

例子：

作用：将s中的字符串复制到字符数组d中。

1

2

3

4

5

6

7

8

9

10

11

12

// memcpy.c

#include <stdio.h>

#include <string.h>

intmain()

{

char*s="Golden Global View";

chard[20];

clrscr();

memcpy(d,s,(strlen(s)+1) );

printf("%s",d);

getchar();

return0;

}

输出结果：Golden Global View

(2)函数原型：extern void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count);
参数说明：dest为目的字符串，src为源字符串，ch为终止复制的字符(即复制过程中遇到ch就停止复制)，count为要拷贝的字节数。
所在库名：#include <string.h>
函数功能：将字符串src中的前n个字节拷贝到dest中，直到遇到字符ch便停止复制。

返回说明：src和dest所指内存区域不能重叠，函数返回void*类型指针

（3）函数原型：extern void *memmove(void *dest, const void *src, unsigned int count)
参数说明：dest为目的字符串，src为源字符串，count为要拷贝的字节数。
所在库名：#include <string.h>
函数功能：将字符串src中的前n个字节拷贝到dest中。
返回说明：dest和src所指内存区域可以重叠，但复制后src内容会被更改。函数返回指向dest的指针。

void * memmove ( void * dst,const void *src,size_t count)

{

       void * ret = dst;

#if defined (_M_MRX000) || defined(_M_ALPHA) || defined (_M_PPC)

       {

       extern void RtlMoveMemory( void *, const void *, size_t count );

       RtlMoveMemory( dst, src, count );

       }

#else /* defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) */

       if (dst <= src || (char *)dst >= ((char *)src + count)) {

                /*

                 * Non-Overlapping Buffers

                 * copy from lower addresses tohigher addresses

                 */

                while (count--) {

                        *(char *)dst = *(char*)src;

                        dst = (char *)dst + 1;

                        src = (char *)src + 1;

                }

       }

       else {

                /*

                 * Overlapping Buffers

                 * copy from higher addressesto 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;

                }

       }

#endif /* defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) */

    return(ret);

}

（4）原型：extern void *memchr(void *buf, char ch, unsigned count);
用法：#include <string.h>
功能：从buf所指内存区域的前count个字节查找字符ch。
说明：当第一次遇到字符ch时停止查找。如果成功，返回指向字符ch的指针；否则返回NULL。

void * memchr (const void * buf,intchr,size_t cnt)

{

        while ( cnt&& (*(unsigned char *)buf != (unsigned char)chr) ) 

       {

               buf = (unsigned char *)buf + 1;

               cnt--;

        }

        return(cnt ?(void *)buf : NULL);
}

（5）原型：extern int memcmp(void *buf1, void *buf2, unsigned int count);
用法：#include <string.h>
功能：比较内存区域buf1和buf2的前count个字节。
说明：
        当buf1<buf2时，返回值<0
        当buf1=buf2时，返回值=0
        当buf1>buf2时，返回值>0

int  memcmp (const void * buf1,const void * buf2,size_t count)

{

       if (!count)

        return(0);

     while ( --count && *(char *)buf1 == *(char *)buf2 )

       {    buf1= (char *)buf1 + 1;

           buf2 = (char *)buf2 + 1;

      }

  return(*((unsigned char *)buf1) - *((unsigned char *)buf2) );

}

（6）原型：extern int memicmp(void *buf1, void *buf2, unsigned int count);
用法：#include <string.h>
功能：比较内存区域buf1和buf2的前count个字节但不区分字母的大小写。
说明：memicmp同memcmp的唯一区别是memicmp不区分大小写字母。
        当buf1<buf2时，返回值<0
        当buf1=buf2时，返回值=0
        当buf1>buf2时，返回值>0

（7）原型：extern void *memset(void *buffer, int c, int count);
用法：#include <string.h>
功能：把buffer所指内存区域的前count个字节设置成字符c。
说明：返回指向buffer的指针。

void *  memset (void *dst,int val,size_tcount)
{

        void *start =dst;

#if defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC)
        {
        extern void RtlFillMemory( void *, size_t count, char);
        RtlFillMemory( dst, count, (char)val );
        }
#else  /* defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) */
        while (count--) {
                *(char *)dst =(char)val;
                dst = (char *)dst + 1;
        }
#endif  /* defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC)*/
        return(start);
}