c++中返回对象与返回引用的区别

这几天在做用C++做课程设计，对其返回对象的实现感到迷惑。

通过对汇编代码的分析，可以清楚的看到，直接返回引用和返回对象的区别到底是什么。

分析的程序如下

#include<cstdio>

class Node
{
public:

    Node(int _num, char *_str):
        num(_num), str(_str)
        {

        }

    int getInt()
    {
        return num;
    };

    void setInt(int n)
    {
        num = n;
    }

    char* getStr()
    {
        return str;
    }
private:
    int num;
    char *str;
};

Node node(,"good");

Node getNode1()
{
    return node;
}

Node& getNode2()
{
    return node;
}
int main()
{
    Node node1 = getNode1();
    printf("%d,%s",node1.getInt(),node1.getStr());
    Node node2 = getNode2();
    printf("%d,%s",node2.getInt(),node2.getStr());
    ;
}

有两个getNode函数，一个直接返回对象，一个返回对象的引用。

反汇编结果（采用MinGW编译器）

. ; Node getNode1()
.                 public __Z8getNode1v
. __Z8getNode1v   proc near               ; CODE XREF: _main+Fp
.                 push    ebp
.                 mov     ebp, esp
.                 mov     eax, ds:_node.num ；将成员num的值放到eax寄存器
.                 mov     edx, ds:_node.str ；将成员str的值放到eda寄存器
.text:0040157E                 pop     ebp
.text:0040157F                 retn
.text:0040157F __Z8getNode1v   endp
.text:0040157F
.
. ; =============== S U B R O U T I N E =======================================
.
. ; Attributes: bp-based frame
.
. ; Node *getNode2()
.                 public __Z8getNode2v
. __Z8getNode2v   proc near               ; CODE XREF: _main+48p
.                 push    ebp
.                 mov     ebp, esp
.                 mov     eax, offset _node ；将node对象的地址值放到eax寄存器
.                 pop     ebp
.                 retn
. __Z8getNode2v   endp
.
.text:0040158A
.text:0040158A ; =============== S U B R O U T I N E =======================================
.text:0040158A
.text:0040158A ; Attributes: bp-based frame
.text:0040158A
.text:0040158A ; int main()
.text:0040158A                 public _main
.text:0040158A _main           proc near               ; CODE XREF: ___tmainCRTStartup+25Dp
.text:0040158A
.
.text:0040158A
.text:0040158A                 push    ebp
.text:0040158B                 mov     ebp, esp
.text:0040158D                 push    ebx
.text:0040158E                 and     esp, 0FFFFFFF0h
.                 sub     esp, 20h        ；开辟栈空间
.                 call    ___main
.                 call    __Z8getNode1v   ; getNode1(void)
.text:0040159E                 mov     [esp+18h], eax  ；取出成员num的值放到栈中
.text:004015A2                 mov     [esp+1Ch], edx  ；去除成员str的值放到栈中
.text:004015A6                 lea     eax, [esp+18h]  ;栈中对象的首地址存取eax寄存器，当作.text:004015AC处函数调用的参数
.text:004015AA                 mov     ecx, eax
.text:004015AC                 call    __ZN4Node6getStrEv ; Node::getStr(void)
.text:004015B1                 mov     ebx, eax
.text:004015B3                 lea     eax, [esp+18h]  ;栈中对象的首地址存取eax寄存器，当作.text:004015B9处函数调用的参数
.text:004015B7                 mov     ecx, eax
.text:004015B9                 call    __ZN4Node6getIntEv ; Node::getInt(void)
.], ebx
.], eax
.text:004015C6                 mov     dword ptr [esp], offset __format ; this
.text:004015CD                 call    __Z6printfPKcz  ; printf(char const*,...)
.text:004015D2                 call    __Z8getNode2v   ; getNode2(void)
.]    ;返回值为Node对象的首地址，存放在eax寄存器中，此处取其成员str的值
.text:004015DA                 mov     eax, [eax]      ;返回值为Node对象的首地址，存放在eax寄存器中，此处取其成员num的值
.text:004015DC                 mov     [esp+10h], eax  ；将Node对象首地址放到栈中（esp+10h处）
.text:004015E0                 mov     [esp+14h], edx
.text:004015E4                 lea     eax, [esp+10h]  ；将栈中esp+10h处存放的Node对象首地址放到eax中，为函数调用的参数
.text:004015E8                 mov     ecx, eax
.text:004015EA                 call    __ZN4Node6getStrEv ; Node::getStr(void)
.text:004015EF                 mov     ebx, eax        ；返回的字符串首地址存在eax寄存器中，此处复制到ebx寄存器中
.text:004015F1                 lea     eax, [esp+10h]  ；将栈中esp+10h处存放的Node对象首地址放到eax中，为函数调用的参数
.text:004015F5                 mov     ecx, eax
.text:004015F7                 call    __ZN4Node6getIntEv ; Node::getInt(void)
.], ebx
.                 ], eax
.                 mov     dword ptr [esp], offset __format ; __format
.text:0040160B                 call    __Z6printfPKcz  ; printf(char const*,...) 此函数参数用栈传递 esp+8为字符串首地址 esp+4为num
.
.                 mov     ebx, [ebp+var_4]
.                 leave
.                 retn
. _main           endp

在汇编代码中，可以清楚的看到函数返回引用实际是返回的一个指针，直接返回对象则会把对象中的数据全部复制（此处只有一个int和一个char指针，所以用了两个寄存器，如果数据项很多则会使用栈传递）。

Node node2 = getNode2(); //此函数返回对象引用

而对于上边这句，由于node2为一个存在栈中的对象，所以会根据getNode1函数返回的指针将其指向对象所有的数据全部拷贝到栈中对象的空间内。

对于

Node node1 = getNode1();//此函数直接返回对象

是将此函数的返回数据全部拷贝到栈中，返回的数据包含原对象的所有数据。

综上

c++中返回对象引用实际是返回的对象指针，直接返回对象会把对象的数据全部拷贝一遍（拷贝到寄存器或栈中）。

而对于将返回值赋值给一个对象时，如果函数返回的是引用，则会根据指针将所有数据拷贝过去，如果返回的是对象，会把返回的对象的数据（可能在寄存器中，或栈中）再拷贝到需赋值的对象中去。

所以

Node node = getNode（）

如果函数返回对象引用，对象的数据会被拷贝一次，如果直接返回对象，则会被拷贝两次。