memcpy函数的实现代码

memcpy函数的实现代码(面试急用)

void memcpy( void * dest, void * src , size_t n)

{

char far * pd = (char far * )dest;

char far * ps = (char far * )src;

long len = (long)sizeof(size_t) * n;

for( long i=0; i

*pd++ = *ps++;

}

TOP 精华推荐：一段小代码，是否出现了野指针？请大家发表一下对野指针理解！（希望能Show 出代码）

改进一下，这样我觉得更安全一点

void memcpy( void * dest, void * src , size_t n)

{

char far * pd = (char far * )dest;

char far * ps = (char far * )src;

long len = (long)sizeof(size_t) * n;

while(len)

{

while((*pd++ = *ps++)!= '\0 ')

len--;

}

}

有2个问题:

1. n不就是要拷贝的字节数?为什么还要乘以sizeof(size_t)? 是sizeof(char)吧?

2. 为什么要far指针呢?是不是要考虑跨段拷贝的情形?

你的方法我好像更不能理解, 为什么要判断 '\0 '呢? 这又不是拷贝字符串.

程序是这样的：

void _fmemcpy(void far *dest, void far* src, long n)

{

while (n-=sizeof(char)) *((char far*)dest)=*((char far*)src);

}

不过，在３２位语言中，far是不必要的

C里面定义的memcpy讲求的是快，没有保证任何的安全性。

抱歉，有个bug，改之

void _fmemcpy(void far *dest, void far* src, long n)

{

do

*((char far*)dest)=*((char far*)src);

while (n-=sizeof(char));

}

extern void *MEMCPY ( void *pDest, const void *pSrc, Length

size )

{

Counter cNumBytes;

char *pD, *pS;

if ((NULL == pSrc) || (NULL == pDest))

return NULL;

pD = ( char * ) pDest;

pS = ( char * ) pSrc;

cNumBytes = 0;

while ( cNumBytes < size )

{

*pD++ = *pS++;

cNumBytes++;

}

return pDest;

}

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

{

void * ret = dst;

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

/* * Non-Overlapping Buffers * copy from lower addresses to higher addresses

*/

while (count--)

*dst++ = *src++;

}

else {

/*

* Overlapping Buffers

* copy from higher addresses to lower addresses

*/

dst += count - 1;

src += count - 1;

while (count--)

*dst-- = *src--;

}

return(ret);

}

#include

void * memcpy(void *s1, const void *s2, register size_t n)

{

register char *p1 = s1;

register const char *p2 = s2;

if (n)

{

n++;

while (--n > 0)

{

*p1++ = *p2++;

}

}

return s1;

}

看看真正的C/C++库的是现代码吧

Func@ memmove, _EXPFUNC, _RTLENTRYF, , ,

Link@ esi,edi

mov edi,dest

mov esi,src

mov ecx,n

mov edx,ecx

cmp edi,esi ; dest < source ?

jb mov_fwd ; yes, do a simple forward move

je mov_end ; dest == source ? do nothing

std ; force esi and edi to decrement

lea esi,[esi+ecx-1] ; point to last byte of source buffer

lea edi,[edi+ecx-1] ; point to last byte of dest buffer

and ecx,3 ; copy trailing bytes rep movsb

mov ecx,edx ; get original count back

shr ecx,1 ; calculate no. of longwords

shr ecx,1

sub esi,3 ; point to previous longword in source

sub edi,3 ; point to previous longword in dest

rep movsd ; copy longwords

cld ; clear direction

flag

jmp short mov_end

mov_fwd:

cld

shr ecx,1

shr ecx,1

rep movsd ; copy longwords

mov ecx,edx ; get original count back

and ecx,3 ; calculate remainder byte count (0-3)

rep movsb ; copy remaining bytes mov_end:

mov eax,dest

Unlink@ esi,edi

Return@

EndFunc@ memmove

做几件事情：

1。内存自身拷贝问题

2。有相交重叠的两块内存的拷贝问题

3。拷贝速度的问题

对于拷贝速度问题，方法是32位机器上双字对齐边界开始拷贝，16位机器上字边界开始拷贝，把内存分为3段：

对齐边界之前的字节，对齐拷贝的字节，最后对齐边界之后的字节

第一段使用一个movsb和movsw完成任务，第二段采用movsd完成，第三段也采用一个movsw和movsb

完成。

面试过程只要说出这三个要点就可以了，程序其实你可以不用编写了

刚才拷贝部分的等价操作如下

memmove(char * src,char *dest, int n) // <-- 实际定义是void *

if( 0 != (long(dest) & 0x1)) O

n--, (*dest++ = *src++);

if( 0 != (long(dest) & 0x2)) {

*(short*)dest++ = *(short*)src++;

n--; n--;

}

int c = n / 4;

while( c -- )

*(long*)dest++ = *(long*)src++;

int k = n %4;

if( k > = 2 ) *(short*)dest++ = *(short*)src++;

if( k == 1 ) *dest++ = src++;

其他再加上一些if判断就可以了

的确memcpy讲求的是效率，下面的代码是c库的实现代码

看一看大师是怎样考虑的。

typedef int word; /* "word " used for optimal copy speed */

#define wsize sizeof(word)

#define wmask (wsize - 1)

void * memcpy(void *dst0, const void *src0, size_t length)

{

char *dst = dst0;

const char *src = src0;

size_t t;

if (length == 0 || dst == src) /* nothing to do */

goto done;

/*

* Macros: loop-t-times; and loop-t-times, t> 0

*/

#define TLOOP(s) if (t) TLOOP1(s)

#define TLOOP1(s) do { s; } while (--t)

if ((unsigned long)dst < (unsigned long)src) {

/*

* Copy forward.

*/

t = (int)src; /* only need low bits */

if ((t | (int)dst) & wmask) {

/*

* Try to align operands. This cannot be done

* unless the low bits match.

*/

if ((t ^ (int)dst) & wmask || length < wsize)

t = length;

else

t = wsize - (t & wmask);

length -= t;

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

}

/*

* Copy whole words, then mop up any trailing bytes.

*/

t = length / wsize;

TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize); t = length & wmask;

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

} else {

/*

* Copy backwards. Otherwise essentially the same.

* Alignment works as before, except that it takes

* (t&wmask) bytes to align, not wsize-(t&wmask).

*/

src += length;

dst += length;

t = (int)src;

if ((t | (int)dst) & wmask) {

if ((t ^ (int)dst) & wmask || length <= wsize)

t = length;

else

t &= wmask;

length -= t;

TLOOP1(*--dst = *--src);

}

t = length / wsize;

TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);

t = length & wmask;

TLOOP(*--dst = *--src);

}

done:

return (dst0);

}

VC:

void* Dest=(void*)pSurf;

void* Src = (void*)pBuffer;

size_t nBytes = (size_t)buffLen;

_asm

{

push edi

push esi

mov esi, dword ptr[Src]

mov edi, dword ptr[Dest]

mov ecx, nBytes

shr ecx, 6 ; nBytes / 64

align 4

Memcpy_Loop:

movq mm0, qword ptr[esi]

movq mm1, qword ptr[esi+8*1]

movq mm2, qword ptr[esi+8*2]

movq mm3, qword ptr[esi+8*3]

movq mm4, qword ptr[esi+8*4]

movq mm5, qword ptr[esi+8*5]

movq mm6, qword ptr[esi+8*6]

movq mm7, qword ptr[esi+8*7] movq qword ptr[edi], mm0

movq qword ptr[edi+8*1], mm1 movq qword ptr[edi+8*2], mm2 movq qword ptr[edi+8*3], mm3 movq qword ptr[edi+8*4], mm4 movq qword ptr[edi+8*5], mm5 movq qword ptr[edi+8*6], mm6 movq qword ptr[edi+8*7], mm7 add esi, 64

add edi, 64

loop Memcpy_Loop

mov ecx, nBytes

and ecx, 63

cmp ecx, 0

je Memcpy_End

rep movsb

Memcpy_End:

emms

pop esi

pop edi

}