为什么返回 std::pair 或 boost::tuple 比通过引用返回效率低得多？在我测试过的实际代码中，通过非常量引用而不是通过内部内核中的 std::pair 设置数据可以将代码速度提高 20%。

作为实验，我研究了三个最简单的情况，涉及将两个(预定义的)整数与两个整数相加:

1. 使用内部内联函数通过引用修改整数

2. 使用两个内部的内联函数按值返回整数

3. 使用一个内部的内联函数返回一个 std::pair，它被复制到结果中。

使用 g++ -c $x -Wall -Wextra -O2 -S 编译会产生相同的汇编代码，用于按引用传递和按值返回整数:

__Z7getPairiRiS_:
LFB19:
    pushq   %rbp
LCFI0:
    leal    1023(%rdi), %eax
    addl    $31, %edi
    movl    %eax, (%rsi)
    movq    %rsp, %rbp
LCFI1:
    movl    %edi, (%rdx)
    leave
    ret

(通过引用代码传递:

#include <utility>

inline void myGetPair(const int inp, int& a, int& b) {
    a = 1023 + inp;
    b = 31 + inp;
}

void getPair(const int inp, int& a, int& b) {
    myGetPair(inp, a, b);
}

使用单独的右值:

#include <utility>

inline int myGetPair1(int inp) {
    return 1023 + inp;
}

inline int myGetPair2(int inp) {
    return 31 + inp;
}

void getPair(const int inp, int& a, int& b) {
    a = myGetPair1(inp);
    b = myGetPair2(inp);
}

)

但是，使用 std::pair 会添加五个额外的汇编语句:

__Z7getPairiRiS_:
LFB18:
    leal    31(%rdi), %eax
    addl    $1023, %edi
    pushq   %rbp
LCFI0:
    salq    $32, %rax
    movq    %rsp, %rbp
LCFI1:
    orq %rdi, %rax
    movq    %rax, %rcx
    movl    %eax, (%rsi)
    shrq    $32, %rcx
    movl    %ecx, (%rdx)
    leave
    ret

该代码几乎与前面的示例一样简单:

#include <utility>

inline std::pair<int,int> myGetPair(int inp) {
    return std::make_pair(1023 + inp, 31 + inp);
}

void getPair(const int inp, int& a, int& b) {
    std::pair<int,int> result = myGetPair(inp);

    a = result.first;
    b = result.second;
}

谁知道编译器的内部工作原理可以帮助解决这个问题吗？ boost tuple page提到了元组与按引用传递的性能损失，但没有一篇链接的论文回答了这个问题。

与这些传递引用语句相比，我更喜欢 std::pair 的原因是它使函数的意图much 在许多情况下更加清晰，尤其是当其他参数输入为以及要修改的那些。

最佳答案

我用 VC++2008 尝试过，使用 cl.exe/c/O2/FAs foo.cpp(即“只编译不链接”、“优化速度”，以及“在注释中转储带有匹配源代码行的程序集输出”)。这就是 getLine() 的最终结果。

“byref”版本:

PUBLIC  ?getPair@@YAXHAAH0@Z                ; getPair
; Function compile flags: /Ogtpy
;   COMDAT ?getPair@@YAXHAAH0@Z
_TEXT   SEGMENT
_inp$ = 8                       ; size = 4
_a$ = 12                        ; size = 4
_b$ = 16                        ; size = 4
?getPair@@YAXHAAH0@Z PROC               ; getPair, COMDAT

; 9    :     myGetPair(inp, a, b);

    mov eax, DWORD PTR _inp$[esp-4]
    mov edx, DWORD PTR _a$[esp-4]
    lea ecx, DWORD PTR [eax+1023]
    mov DWORD PTR [edx], ecx
    mov ecx, DWORD PTR _b$[esp-4]
    add eax, 31                 ; 0000001fH
    mov DWORD PTR [ecx], eax

; 10   : }

    ret 0
?getPair@@YAXHAAH0@Z ENDP               ; getPair

“byval”std::pair-返回版本:

PUBLIC  ?getPair@@YAXHAAH0@Z                ; getPair
; Function compile flags: /Ogtpy
;   COMDAT ?getPair@@YAXHAAH0@Z
_TEXT   SEGMENT
_inp$ = 8                       ; size = 4
_a$ = 12                        ; size = 4
_b$ = 16                        ; size = 4
?getPair@@YAXHAAH0@Z PROC               ; getPair, COMDAT

; 8    :     std::pair<int,int> result = myGetPair(inp);

    mov eax, DWORD PTR _inp$[esp-4]

; 9    : 
; 10   :     a = result.first;

    mov edx, DWORD PTR _a$[esp-4]
    lea ecx, DWORD PTR [eax+1023]
    mov DWORD PTR [edx], ecx

; 11   :     b = result.second;

    mov ecx, DWORD PTR _b$[esp-4]
    add eax, 31                 ; 0000001fH
    mov DWORD PTR [ecx], eax

; 12   : }

    ret 0
?getPair@@YAXHAAH0@Z ENDP               ; getPair

如您所见，实际的 assembly 是相同的；唯一的区别在于名称和注释的困惑。

关于c++ - 返回 std::pair 与通过非常量引用传递，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1869171/