Neu zuordnen des Objekts unique_ptr mit make_unique-Anweisungen - Speicherleck?

Question

Ich verstehe nicht, was folgende Anweisung tun würde (besonders zweite Zeile)?

auto buff = std::make_unique<int[]>(128); 
buff = std::make_unique<int[]>(512); 

Wird der zweite Aufruf von make_unique durch Zuweisungsoperator gefolgt wird de-allocate Speicher von ersten Anruf zugeordnet ist, oder wird es Speicherleck sein? Muss ich buff.reset(new int[512]); verwenden?

Ich habe es debuggt, aber keine operator= aufgerufen, noch ein Destruktor aufgerufen (von unique_ptr).

Answer 1

gcc 5.3:

#include <memory> 

extern void emit(int*); 

int main() 
{ 
    // declare and initialise buf 
    auto buff = std::make_unique<int[]>(128); 

    // make_unique on the RHS returns a temporary 
    // - therefore an r-value reference 

    // therefore this becomes and operator=(unique_ptr&&) 
    // (move-assignment) 
    buff = std::make_unique<int[]>(512); 

    // something to get the compiler to emit code 
    emit(buff.get()); 
} 

ergibt Montage:

main: 
     pushq %r12 
     movl $512, %edi 
     pushq %rbp 
     pushq %rbx 
     call operator new[](unsigned long) ; <-- new (1) 
     movl $64, %ecx 
     movq %rax, %rbp 
     xorl %eax, %eax 
     movq %rbp, %rdi 
     rep stosq 
     movl $2048, %edi 
     call operator new[](unsigned long) ; <<-- new (2) 
     movl $2048, %edx 
     xorl %esi, %esi 
     movq %rax, %rdi 
     movq %rax, %rbx 
     call memset 
     movq %rbp, %rdi 
     call operator delete[](void*)  ;<-- delete (1) 
     movq %rbx, %rdi 
     call emit(int*) 
     movq %rbx, %rdi 
     call operator delete[](void*)  ;<-- delete (2) 
     popq %rbx 
     xorl %eax, %eax 
     popq %rbp 
     popq %r12 
     ret 
     movq %rax, %r12 
     movq %rbp, %rbx 
.L3: 
     movq %rbx, %rdi 
     vzeroupper 
     call operator delete[](void*)  ;<-- handles a failed assignment 
     movq %r12, %rdi 
     call _Unwind_Resume 
     movq %rax, %r12 
     jmp  .L3 

Answer 2

Hier gibt es kein Speicherleck, die Zuordnung hebt die Ressourcen auf, die der ersten Zuweisung zugeordnet sind. Wenn Sie es im Debugger nicht sehen, bedeutet dies höchstwahrscheinlich, dass der entsprechende Anruf gerade optimiert wurde. Versuchen Sie, mit -O0 zu kompilieren, wenn Sie es sehen möchten.

Answer 3

Verschieben Zuweisungsoperator aufgerufen, die tut

if (this != &_Right) 
{ // different, do the swap 
    reset(_Right.release()); 
    this->get_deleter() = _STD move(_Right.get_deleter()); 
} 

Kein Leck hier, wie es zurückgesetzt tut, das wird freischalten.