emplace_back与push_back的原始类型

Question

我想知道使用原始标量类型（例如或）时，emplace_back和push_back的std::vector行为是否有所不同。凭直觉，我猜想在编译之后，这两个变体在这里都将导致相同的字节码：std::uint32_tstd::uint8_t

void copyListContent(std::uint8_t * list, std::size_t nElems,
                     std::vector<std::uint8_t> & vec)
{
    vec.clear();
    vec.reserve(nElems);
    for (std::size_t i = 0; i < nElems; ++i)
    {
        //variant 1:
        vec.push_back(list[i]);
        //variant 2:
        vec.emplace_back(list[i]);
    }        
}

如果那应该已经不对了，请纠正我。

现在，我开始挣扎的是当我问自己“列表”和向量的类型不匹配时会发生什么：

void copyListContent(std::uint8_t * list, std::size_t nElems,
                     std::vector<std::uint32_t> & vec)
{
    //... same code as above      
}

将std::uint8_t元素std::uint32_t放入向量中时（使用emplace_back或push_back），这些元素将转换为，因此我想知道是否会触发某些“构造函数”的调用？在那种情况下，会emplace_back更有效，因为它将避免构造将要复制的临时对象？还是这些隐式转换没有任何作用，emplace_back并且push_back将表现相同？

于是，我问自己，你： 对于基本类型，如这些，都emplace_back和push_back总行为类似？

一个模糊的猜测是，我会说“大概是”，但是我对C ++内部的了解不足，无法可靠地自己回答这个问题。在这种情况下，我很乐意了解事情的工作原理-非常感谢！

Answer 1

GCC将这两个版本的代码编译为相同的结果程序集（Godbolt.org）：

#include<vector>

void push(std::vector<int> & vec, int val) {
    vec.push_back(val);
}

与

#include<vector>

void push(std::vector<int> & vec, int val) {
    vec.emplace_back(val);
}

两者都导致以下组装：

push(std::vector<int, std::allocator<int> >&, int):
        push    r15
        push    r14
        push    r13
        push    r12
        push    rbp
        push    rbx
        sub     rsp, 24
        mov     rbx, QWORD PTR [rdi+8]
        cmp     rbx, QWORD PTR [rdi+16]
        je      .L2
        mov     DWORD PTR [rbx], esi
        add     rbx, 4
        mov     QWORD PTR [rdi+8], rbx
        add     rsp, 24
        pop     rbx
        pop     rbp
        pop     r12
        pop     r13
        pop     r14
        pop     r15
        ret
.L2:
        mov     r12, QWORD PTR [rdi]
        mov     r14, rbx
        mov     ecx, esi
        mov     rbp, rdi
        sub     r14, r12
        mov     rax, r14
        sar     rax, 2
        je      .L9
        lea     rdx, [rax+rax]
        mov     r15, -4
        cmp     rax, rdx
        ja      .L4
        movabs  rsi, 4611686018427387903
        cmp     rdx, rsi
        jbe     .L19
.L4:
        mov     rdi, r15
        mov     DWORD PTR [rsp], ecx
        call    operator new(unsigned long)
        mov     ecx, DWORD PTR [rsp]
        mov     r13, rax
        add     r15, rax
.L5:
        lea     rax, [r13+4+r14]
        mov     DWORD PTR [r13+0+r14], ecx
        mov     QWORD PTR [rsp], rax
        cmp     rbx, r12
        je      .L6
        mov     rdx, r14
        mov     rsi, r12
        mov     rdi, r13
        call    memmove
.L7:
        mov     rdi, r12
        call    operator delete(void*)
.L8:
        mov     QWORD PTR [rsp+8], r13
        movq    xmm0, QWORD PTR [rsp+8]
        mov     QWORD PTR [rbp+16], r15
        movhps  xmm0, QWORD PTR [rsp]
        movups  XMMWORD PTR [rbp+0], xmm0
        add     rsp, 24
        pop     rbx
        pop     rbp
        pop     r12
        pop     r13
        pop     r14
        pop     r15
        ret
.L6:
        test    r12, r12
        je      .L8
        jmp     .L7
.L9:
        mov     r15d, 4
        jmp     .L4
.L19:
        xor     r15d, r15d
        xor     r13d, r13d
        test    rdx, rdx
        je      .L5
        lea     r15, [0+rax*8]
        jmp     .L4

正如您可能已经推论的那样，在处理具有更复杂的构造/复制/移动行为的类型时，这不是您可以依赖的行为，但是对于原始类型而言，差别可以忽略不计。

话虽如此，在一种情况下可能会有所不同：

std::vector<int16_t> vec;
size_t seed = 0x123456789abcdef;

vec.push_back(seed);

与

vec.emplace_back(seed);

在（经过适当优化的）编译器中，两个汇编代码可能会完全相同，但是您会从编译器收到不同的缩小警告（或错误，如果强行使警告导致编译失败）。后者更有可能发出难以诊断的警告消息，因为错误将源自内部<vector>而不是内部进行调用的任何.cpp文件。