C 语言结构体赋值分析和其优点（使用方式和汇编分析）

1. 例子

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Foo
{
    char a;
    int b;
    double c;
};

int main()
{
    // 定义结构体对象
    struct Foo foo1;
    struct Foo foo2;

    // 初始化为 0
    memset(&foo1, 0, sizeof(foo1));
    memset(&foo2, 0, sizeof(foo2));

    // 初始 foo1 的值
    foo1.a = 'a';
    foo1.b = 1;
    foo1.c = 3.14;

    // 结构体赋值：将 foo1 赋值给 foo2
    foo2 = foo1;

    memcpy(&foo2, &foo1, sizeof(foo1));

    // 打印 foo2 的值
    printf("%c   %d   %lf\n", foo2.a, foo2.b, foo2.c); // a   1   3.140000

    return 0;
}

上面我们定义的两个结构体，给第一个结构体 foo1 赋值初始化，然后我们将第一个结构体直接复制给第二个结构体,这一段代码是能够正常运行的，另外，我们使用 memcpy 这个函数将第一个结构体复制给第二个结构体它们的功能是一样的。

2. 反汇编

2.1 gcc 汇编

我们可以通过反汇编的方法看一下这两种方式，哪一种方式的效率更高。

在结构体赋值中，

foo2 = foo1;

生成的汇编：

        mov     rax, QWORD PTR [rbp-16]
        mov     rdx, QWORD PTR [rbp-8]
        mov     QWORD PTR [rbp-32], rax
        mov     QWORD PTR [rbp-24], rdx

对比在 gcc 中，

memcpy(&foo2, &foo1, sizeof(foo1));

生成的汇编是一样的：

        mov     rax, QWORD PTR [rbp-16]
        mov     rdx, QWORD PTR [rbp-8]
        mov     QWORD PTR [rbp-32], rax
        mov     QWORD PTR [rbp-24], rdx

其实这是 gcc 编译器优化的结果，但也能看出，结构体赋值，是将 foo1 的内容，按寄存器的大小，在这里是 8 个字节，以每次8个字节的复制到 foo2。假如说你是开发编译器的人，这已经是机器所能达到的最优解了。

2.2 VS clang 汇编

在结构体赋值中，

foo2 = foo1;

生成的汇编就是将 foo1 的数据每次通过寄存器按寄存器的大小赋值给 foo2：

        mov     edx, DWORD PTR _foo1$[ebp]
        mov     DWORD PTR _foo2$[ebp], edx
        mov     eax, DWORD PTR _foo1$[ebp+4]
        mov     DWORD PTR _foo2$[ebp+4], eax
        mov     ecx, DWORD PTR _foo1$[ebp+8]
        mov     DWORD PTR _foo2$[ebp+8], ecx
        mov     edx, DWORD PTR _foo1$[ebp+12]
        mov     DWORD PTR _foo2$[ebp+12], edx

而使用 clang DEBUG 模式进行反汇编时，会调用 memcpy 函数

memcpy(&foo2, &foo1, sizeof(foo1));

生成的汇编：

        push    16                                  ; 00000010H
        lea     eax, DWORD PTR _foo1$[ebp]
        push    eax
        lea     ecx, DWORD PTR _foo2$[ebp]
        push    ecx
        call    memcpy

调用 memcpy 这个函数时的耗时就大于上面的结构体赋值了。

我们看一下它的源码，这个就是按字节赋值，没有经过优化：

void *memcpy(void *dst, const void *src, size_t len)
{
	if(NULL == dst || NULL == src){
		return NULL;
	}
	
	void *ret = dst;
	
	if(dst <= src || (char *)dst >= (char *)src + len){
		//没有内存重叠，从低地址开始复制
		while(len--){
			*(char *)dst = *(char *)src;
			dst = (char *)dst + 1;
			src = (char *)src + 1;
		}
	}else{
		//有内存重叠，从高地址开始复制
		src = (char *)src + len - 1;
		dst = (char *)dst + len - 1;
		while(len--){
			*(char *)dst = *(char *)src;
			dst = (char *)dst - 1;
			src = (char *)src - 1;
		}
	}
	return ret;
}

3. 总结

结构体赋值是 C 语言中一个很好用的特性。

1. 它不需要 memcpy 调用那么复杂
2. 它已经经过了编译器优化，以最快的方式运行。
3. 在结构体数组中，如果需要对结构体数组的元素进行排序时，使用结构体赋值具有很好的可读性，它让你写起代码就像是对一个整型数组进行排序一样。
4. 结构体赋值在使用时编译器可以对类型进行判断，可以在编译时就预防错误。而 memcpy 使用起来一个参数也不能输错，容易造成错误。