memcpy（）求解,该如何解决

memcpy（）求解
我看memcpy（）源码是没有对内存重叠进行处理的，但是我写了一段测试code，结果不是逾期的啊，求指教.

char t[10] = {'A','B','C','D','E'}；
char *d；

d = （char *）memcpy（&t[1],&t[0]，2）；

printf（“the t is %s\n”，t）；

打印的结果是：AABDE

如果没有处理内存重叠，

不是应该是
t[0] = 'A';
t[1] = 'A';
t[2] = 'A';
吗？
结果应该是AAADE吗?

求解

[解决办法]

引用:


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

#if defined (_M_IA64) 
[解决办法]
 defined (_M_AMD64)

        {


        __declspec(dllimport)


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

        RtlMoveMemory( dst, src, count );

        }

#else  /* defined (_M_IA64) 
[解决办法]
 defined (_M_AMD64) */
        if (dst &lt;= src 
[解决办法]
 (char *)dst &gt;= ((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_IA64) 
[解决办法]
 defined (_M_AMD64) */

        return(ret);
}

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

#if defined (_M_IA64)

        {


        __declspec(dllimport)


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

        RtlCopyMemory( dst, src, count );

        }

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

        return(ret);
}

有码有真相啊。
memcpy就是会判断是从高地址复制到底地址还是从底地址到高地址，反正不会先覆盖再复制的。

memcpy（）求解,该如何解决

热点推荐