关于C++对象作为参数详解

有时我们会将对象作为参数传入函数，其中有不少所谓的“陷阱”，大部分都与对象中申请的内存释放有关，到底是什么原因导致的这些问题呢？所谓的默认的拷贝构造函数又是什么呢？它又做了怎么样的工作，编译器又是怎么样调用它的呢？让我们一起走进C++的内部世界

当类所占用的空间很小时，比如只有几个int数据成员，编译器会选择直接将几个数据成员做压栈操作（先声明的数据后压栈，后声明的数据先压栈），以供调用函数使用

测试代码：

class UnitTest
{
public:
    int m_One;
    int m_Two;
};

void ShowUnitTest(UnitTest unit)
{
    printf("%d %d %s\n", unit.m_One, unit.m_Two);
}

int main(int argc, char *argv[])
{
    UnitTest test;

    test.m_One = 1;
    test.m_Two = 2;

    ShowUnitTest(test);

    system("pause");
    return 0;
}

看其反汇编的代码：

int main(int argc, char *argv[])
{
00BB1420  push        ebp  
00BB1421  mov         ebp,esp  
00BB1423  sub         esp,0D0h  
00BB1429  push        ebx  
00BB142A  push        esi  
00BB142B  push        edi  
00BB142C  lea         edi,[ebp-0D0h]  
00BB1432  mov         ecx,34h  
00BB1437  mov         eax,0CCCCCCCCh  
00BB143C  rep stos    dword ptr es:[edi]  
    UnitTest test;

    test.m_One = 1;
00BB143E  mov         dword ptr [test],1  
    test.m_Two = 2;
00BB1445  mov         dword ptr [ebp-8],2  

    ShowUnitTest(test);
00BB144C  mov         eax,dword ptr [ebp-8]  
00BB144F  push        eax  
00BB1450  mov         ecx,dword ptr [test]  
00BB1453  push        ecx  
00BB1454  call        ShowUnitTest (0BB11E5h)  

可以看到00BB144C 的压栈顺序确实是先声明后压栈，后声明先压栈，直接使用push解决问题。

---

再下面我们看一下类的体积较大时编译器的处理过程

先看一段代码：

class UnitTest
{
public:
    int m_One;
    int m_Two;
    char m_sName[32];
};

void ShowUnitTest(UnitTest unit)
{
    printf("%d %d %s\n", unit.m_One, unit.m_Two, unit.m_sName);
}

int main(int argc, char *argv[])
{
    UnitTest test;
    test.m_One = 1;
    test.m_Two = 2;
    char tmp[] = "name";
    strncpy_s(test.m_sName, tmp, sizeof(tmp));

    ShowUnitTest(test);

    system("pause");
    return 0;
}

反汇编代码为：

int main(int argc, char *argv[])
{
00053D00  push        ebp  
00053D01  mov         ebp,esp  
00053D03  sub         esp,104h  
00053D09  push        ebx  
00053D0A  push        esi  
00053D0B  push        edi  
00053D0C  lea         edi,[ebp-104h]  
00053D12  mov         ecx,41h  
00053D17  mov         eax,0CCCCCCCCh  
00053D1C  rep stos    dword ptr es:[edi]  
00053D1E  mov         eax,dword ptr ds:[00058004h]  
00053D23  xor         eax,ebp  
00053D25  mov         dword ptr [ebp-4],eax  
    UnitTest test;
    test.m_One = 1;
00053D28  mov         dword ptr [test],1  
    test.m_Two = 2;
00053D2F  mov         dword ptr [ebp-2Ch],2  
    char tmp[] = "name";
00053D36  mov         eax,dword ptr ds:[00055864h]  
00053D3B  mov         dword ptr [tmp],eax  
00053D3E  mov         cl,byte ptr ds:[55868h]  
00053D44  mov         byte ptr [ebp-3Ch],cl  
    strncpy_s(test.m_sName, tmp, sizeof(tmp));
00053D47  push        5  
00053D49  lea         eax,[tmp]  
00053D4C  push        eax  
00053D4D  lea         ecx,[ebp-28h]  
00053D50  push        ecx  
00053D51  call        strncpy_s<32> (0511EFh)  
00053D56  add         esp,0Ch  

    ShowUnitTest(test);
00053D59  sub         esp,28h  
00053D5C  mov         ecx,0Ah  
00053D61  lea         esi,[test]  
00053D64  mov         edi,esp  
00053D66  rep movs    dword ptr es:[edi],dword ptr [esi]  
00053D68  call        ShowUnitTest (0511E5h)  

我们直接观察0x00053D59 开始调用ShowUnitTest处的汇编代码：
我们发现首先通过栈指着esp 开辟了0x28H（40）大小的空间，正好是UnitTest对象的大小。
然后通过rep movs 指令将对象test拷贝了一份到此处。

而这里的操作即是《C++ Primer》中所说的调用默认拷贝构造函数并创建的临时变量。

编译器在这里插入了申请栈空间及直接复制对象在栈上内存的内存数据的汇编指令（即浅拷贝）

然后我们观察ShowUnitTest的内部实现：

ShowUnitTest:
00281420  push        ebp  
00281421  mov         ebp,esp  
00281423  sub         esp,0C0h  
00281429  push        ebx  
0028142A  push        esi  
0028142B  push        edi  
0028142C  lea         edi,[ebp-0C0h]  
00281432  mov         ecx,30h  
00281437  mov         eax,0CCCCCCCCh  
0028143C  rep stos    dword ptr es:[edi]  
    printf("%d %d %s\n", unit.m_One, unit.m_Two, unit.m_sName);
0028143E  mov         esi,esp  
00281440  lea         eax,[ebp+10h]  
00281443  push        eax  
00281444  mov         ecx,dword ptr [ebp+0Ch]  
00281447  push        ecx  
00281448  mov         edx,dword ptr [unit]  
0028144B  push        edx  
0028144C  push        2859DCh  
00281451  call        dword ptr ds:[289118h]  
00281457  add         esp,10h  
0028145A  cmp         esi,esp  
0028145C  call        __RTC_CheckEsp (028113Bh)  
}

从00281440这里可以看出，程序在向ebp的下方（即更高的地址位置）进行寻址操作，而操作的位置就是该函数的调用函数的栈帧，而 ebp + 10h 对应的就是临时变量的m_sName的首地址，ebp+0Ch 即临时对象m_Two的首地址， [unit] 即ebp+08 ，即临时对象的首地址，也就是对象m_One的位置。

结论

当对象作为参数传入时（非引用或指针传入时），编译器会在调用该函数前插入拷贝汇编代码，以用来在当前栈帧中生成临时变量，进入被调用的函数后，向搞地址寻址，对临时对象进行读写操作，与原对象彻底无关。