闲着无聊写了两个内存复制的函数，不运行测试猜猜哪个更快，为什么你认为你所选的会更快

[Sandrer]

void *memcpy1(void *dst, const void *src, size_t size)
{
    void *ret = dst;

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

    return ret;
}

void *memcpy2(void *dst, const void *src, size_t size)
{
    void *ret = dst;

    size_t block = size / 4;

    while (block--)
    {
        *(int *)dst = *(int *)src;
        dst = (int *)dst + 1;
        src = (int *)src + 1;
    }

    size_t mod = size % 4;
    if (mod)
    {
        while (mod--)
        {
            *(char *)dst = *(char *)src;
            dst = (char *)dst + 1;
            src = (char *)src + 1;
        }
    }

    return ret;
}

[laviewpbt]

够无聊，这个东西的优化都是靠SSE，AVX等指令的、

[hemmingway]

看看这个

void *memcpy_optimized(void *dst, const void *src, size_t sz)
{
	void *r = dst;

	//先进行uint64_t长度的拷贝，一般而言，内存地址都是对齐的，
	size_t n = sz & ~(sizeof(uint64_t) - 1);
	uint64_t *src_u64 = (uint64_t *) src;
	uint64_t *dst_u64 = (uint64_t *) dst;

	while (n)
	{
		*dst_u64++ = *src_u64++;
		n -= sizeof(uint64_t);
	}

	//将没有非8字节字长取整的部分copy
	n = sz & (sizeof(uint64_t) - 1);
	byte *src_u8 = (byte *) src;
	byte *dst_u8 = (byte *) dst;
	while (n-- )
	{
		(*dst_u8++ = *src_u8++);
	}

	return r;

	return NULL;
}

[杀意已决]

猜第二个 .

[yaozhiyong110]

猜第二个 因为第一个太常规

[xiaohuh421]

*(int *)dst = *(int *)src; 这种东西可能会影响效率, 已经影响测试效果了. 按理来说, 应该是按4字节复制更快些, 因为一般32位系统中都是4字节对齐处理快于单字节. 当然还有64位复制, 或者更快的MMX指令.

[__cc__]

引用 楼主 Sandrer 的回复:

void *memcpy1(void *dst, const void *src, size_t size)
{
    void *ret = dst;

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

    return ret;
}

void *memcpy2(void *dst, const void *src, size_t size)
{
    void *ret = dst;

    size_t block = size / 4;

    while (block--)
    {
        *(int *)dst = *(int *)src;
        dst = (int *)dst + 1;
        src = (int *)src + 1;
    }

    size_t mod = size % 4;
    if (mod)
    {
        while (mod--)
        {
            *(char *)dst = *(char *)src;
            dst = (char *)dst + 1;
            src = (char *)src + 1;
        }
    }

    return ret;
}

AVX更快，一次128字节。

[这不是鸭头]

[linktothepast]

你都还没有判断src 和dst 是否对齐呢