为什么我们不在函数中通过引用传递 POD？

Question

一直有人告诉我，我们不应该通过引用传递 POD。但最近我发现引用实际上根本不占用内存。

那我们为什么选择写作：

void DoSomething(int iNumber);

代替：

void DoSomething(const int& riNumber);

不是更有效率吗？

Answer 1

实际上在这种情况下（使用 int）按值传递可能更有效，因为访问传递的值只需要 1 次内存读取而不是 2 次。

示例（使用 -O2 优化）：

int gl = 0;

void f1(int i)
{
    gl = i + 1;
}

void f2(const int& r)
{
    gl = r + 1;
}

int main()
{
    f1(1);

    f2(1);
}

组合

    .file   "main.cpp"
    .text
    .p2align 2,,3
.globl __Z2f1i
    .def    __Z2f1i;    .scl    2;  .type   32; .endef
__Z2f1i:
LFB0:
    pushl   %ebp
LCFI0:
    movl    %esp, %ebp
LCFI1:
    movl    8(%ebp), %eax
    incl    %eax
    movl    %eax, _gl
    leave
    ret
LFE0:
    .p2align 2,,3
.globl __Z2f2RKi
    .def    __Z2f2RKi;  .scl    2;  .type   32; .endef
__Z2f2RKi:
LFB1:
    pushl   %ebp
LCFI2:
    movl    %esp, %ebp
LCFI3:
    movl    8(%ebp), %eax
    movl    (%eax), %eax
    incl    %eax
    movl    %eax, _gl
    leave
    ret
LFE1:
    .def    ___main;    .scl    2;  .type   32; .endef
    .p2align 2,,3
.globl _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
LFB2:
    pushl   %ebp
LCFI4:
    movl    %esp, %ebp
LCFI5:
    andl    $-16, %esp
LCFI6:
    call    ___main
    movl    $2, _gl
    xorl    %eax, %eax
    leave
    ret
LFE2:
.globl _gl
    .bss
    .align 4
_gl:
    .space 4

Answer 2

不通过引用传递 POD 似乎是一个过于笼统的规则。 POD 可能很大，传递对它的引用是值得的。在您的特定情况下，int 与大多数（如果不是全部）实现在后台用于实际实现引用的指针大小相同。传递 int 或引用之间没有大小差异，但现在你有额外间接级别的惩罚。

Answer 3

引用传递就是变相的指针传递。

对于小数据，将其作为值访问会更快，而不必多次引用指针。

Answer 4

因为它在 99.999% 的时间内是无意义的效率提升，而且它改变了语义。它还可以防止您传入一个常量值。例如：

void Foo(int &i) { }
Foo(1);  // ERROR!

但是这会起作用：

void Foo(const int &i) { }
Foo(1);

此外，这意味着该函数可以修改 i 的值，使其对调用者可见，这很可能是一件坏事（但同样，您当然可以使用 const 引用）。它归结为优化程序中重要的部分，并使其余代码的语义尽可能正确。

引用实际上完全不占用内存。

不确定是谁告诉你的，但这不是真的。

Answer 5

取决于你所说的效率。

我们通过常量引用传递对象的主要原因是因为按值这样做会调用对象的复制构造函数，而这可能是一项昂贵的操作。

复制int 很简单。

Answer 6

没有正确答案，甚至没有明显的普遍偏好。在某些情况下，按值传递可以更快，而且非常重要的是，可以消除副作用。在其他情况下，通过引用传递可以更快，并允许更容易地从给定函数返回信息。这适用于 POD 数据类型。请记住，结构可以是 POD，因此 POD 之间的大小考虑也会有所不同。

Answer 7

真正的答案是习惯。
我们有一种根深蒂固的文化，即尝试对我们的代码进行宏优化（即使它很少产生任何真正的影响）。如果您能告诉我代码通过值/引用（整数）传递有什么不同，我会感到惊讶。

一旦您开始通过模板隐藏类型，我们就会再次开始使用 const 引用（因为复制某些类型可能很昂贵）。

现在，如果您询问的是通用 POD，则可能存在成本差异，因为 POD 可能会变得非常大。

第一个版本有一个小优势，如果我们改变原始值，我们不需要额外的标识符。

void DoSomething(int iNumber)
{
    for(;iNumber > 0; --iNumber)   // mutating iNumber
    {
       // Stuff
    }
}

// No real cost difference in code.
// Just in the amount of text we need to read to understand the code
//
void DoSomething(int const& iNumber)
{
    for(int loop = iNumber;loop > 0; --loop)   // mutating new identifier
    {
       // Stuff
    }
}

Answer 8

不，不是。与 int 的示例完全相同。 当你有“更重”的物体时，这很重要。