• memcpy

描述
C 库函数 void *memcpy(void *str1, const void *str2, size_t n) 从存储区 str2 复制 n 个字符到存储区 str1。
声明
下面是 memcpy() 函数的声明。
void *memcpy(void str1, const void str2, size_t n)
参数
str1 – 指向用于存储复制内容的目标数组，类型强制转换为 void 指针。
str2 – 指向要复制的数据源，类型强制转换为 void 指针。
n – 要被复制的字节数。
返回值
该函数返回一个指向目标存储区 str1 的指针。

/* memcpy example */
// 将字符串复制到数组 dest 中
#include <stdio.h>
#include <string.h>
 
int main ()
{
   const char src[50] = "http://www.runoob.com";
   char dest[50];
 
   memcpy(dest, src, strlen(src)+1);
   printf("dest = %s\n", dest);
   
   return(0);
}

/*simulation of memcpy1*/
#include <stdio.h>
#include <string.h>

void* Memcpy(void* str1, const void* str2, size_t n)
{
	void* ret = str1;
	for(int i = 0; i<n; ++i)
		*((char*)str1 + i) = *((char*)str2 + i);
	return ret;
}

int main()
{
	const char src[50] = "http://www.runoob.com";
	char dest[50];

	Memcpy(dest, src, strlen(src) + 1);
	printf("dest = %s\n", dest);

	return(0);
}

/*simulation of memcpy2*/
#include <stdio.h>
#include <string.h>

void* Memcpy(void* str1, const void* str2, size_t n)
{
	void* ret = str1;
	while(n--)
	{
		*(char*)str1  = *(char*)str2; 
		str1 = (char*)str1 + 1;
		str2 = (char*)str2 + 1;
	}
	return ret;
}

int main()
{
	const char src[50] = "http://www.runoob.com";
	char dest[50];

	Memcpy(dest, src, strlen(src) + 1);
	printf("dest = %s\n", dest);

	return(0);
}

/*simulation of memcpy3 鲍*/
#include <stdio.h>
#include <string.h>
void* Memcpy(void* dest, const void* sour, size_t count)
{
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)sour;
		dest = (char*)dest + 1;
		sour = (char*)sour + 1;
	}
	return ret;
}


int main()
{
	const char src[50] = "http://www.runoob.com";
	char dest[50];

	Memcpy(dest, src, strlen(src) + 1);
	printf("dest = %s\n", dest);

	return(0);
}

/*memcpy in lib*/
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);
}

• memmove

描述
C 库函数 void *memmove(void *str1, const void *str2, size_t n) 从 str2 复制 n 个字符到 str1，但是在重叠内存块这方面，memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话，memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，复制后源区域的内容会被更改。如果目标区域与源区域没有重叠，则和 memcpy() 函数功能相同。
声明
下面是 memmove() 函数的声明。
void *memmove(void str1, const void str2, size_t n)
参数
str1 – 指向用于存储复制内容的目标数组，类型强制转换为 void 指针。
str2 – 指向要复制的数据源，类型强制转换为 void 指针。
n – 要被复制的字节数。
返回值
该函数返回一个指向目标存储区 str1 的指针。

/* memmove example */
#include <stdio.h>
#include <string.h>

int main ()
{
   const char dest[] = "oldstring";
   const char src[]  = "newstring";

   printf("Before memmove dest = %s, src = %s\n", dest, src);
   memmove(dest, src, 9);
   printf("After memmove dest = %s, src = %s\n", dest, src);

   return(0);
}

/*simulation of memmove */
#include <stdio.h>
void* Memmove(void* dest, const void* src, size_t count)
{
	void* ret = dest;
	if (dest <= src || (char*)src + count <= dest)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	else  //(char*)src + count >= dest
	{
		char* start_dest = (char*)dest + count - 1;
		char* start_src  = (char*) src + count - 1;
		while (count--)
			*start_dest-- = *start_src--;

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

int main()
{
	char dest[] = "oldstring";
	char src[] = "newstring";

	printf("Before memmove dest = %s, src = %s\n", dest, src);
	Memmove(dest, src, 9);
	printf("After memmove dest = %s, src = %s\n", dest, src);

	return(0);
}

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

#if defined (_M_X64)

        {


        __declspec(dllimport)


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

        RtlMoveMemory( dst, src, count );

        }

#else  /* defined (_M_X64) */
        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;
                }
        }
#endif  /* defined (_M_X64) */

        return(ret);
}