Why does unique_ptr instantiation compile to larger binary than raw pointer?

Question

I was always under the impression that a std::unique_ptr had no overhead compared to using a raw pointer. However, compiling the following code

#include <memory>

void raw_pointer() {
  int* p = new int[100];
  delete[] p;
}

void smart_pointer() {
  auto p = std::make_unique<int[]>(100);
}

with g++ -std=c++14 -O3 produces the following assembly:

raw_pointer():
        sub     rsp, 8
        mov     edi, 400
        call    operator new[](unsigned long)
        add     rsp, 8
        mov     rdi, rax
        jmp     operator delete[](void*)
smart_pointer():
        sub     rsp, 8
        mov     edi, 400
        call    operator new[](unsigned long)
        lea     rdi, [rax+8]
        mov     rcx, rax
        mov     QWORD PTR [rax], 0
        mov     QWORD PTR [rax+392], 0
        mov     rdx, rax
        xor     eax, eax
        and     rdi, -8
        sub     rcx, rdi
        add     ecx, 400
        shr     ecx, 3
        rep stosq
        mov     rdi, rdx
        add     rsp, 8
        jmp     operator delete[](void*)

Why is the output for smart_pointer() almost three times as large as raw_pointer()?

It does have a counter involved and perhaps a little overhead. Perhaps a vtable — Ed Heal, Nov 16 '16 at 14:56
I am actually surprised the whole thing is not optimized away altogether. — SergeyA, Nov 16 '16 at 15:07
Yes, I was checking it at the same time. Looks like CLang is starting to pick up with gcc on optimizations. — SergeyA, Nov 16 '16 at 15:08
@SergeyA if it's separately compiled I guess the compiler has to allow for the possibility that you overloaded `new` and `delete` to have other side-effects? — Alex Celeste, Nov 16 '16 at 19:04
@EdHeal Counter? Vtable? That doesn't really apply to `std::unique_ptr`, does it? — milleniumbug, Nov 16 '16 at 21:53

score 53 · Accepted Answer · edited May 23 '17 at 12:34

53

Because std::make_unique<int[]>(100) performs value initialization while new int[100] performs default initialization - In the first case, elements are 0-initialized (for int), while in the second case elements are left uninitialized. Try:

int *p = new int[100]();

And you'll get the same output as with the std::unique_ptr.

See this for instance, which states that std::make_unique<int[]>(100) is equivalent to:

std::unique_ptr<T>(new int[100]())

If you want a non-initialized array with std::unique_ptr, you could use¹:

std::unique_ptr<int[]>(new int[100]);

_{¹ As mentioned by @Ruslan in the comments, be aware of the difference between std::make_unique() and std::unique_ptr() - See Differences between std::make_unique and std::unique_ptr.}

edited May 23 '17 at 12:34

Community

1
1

answered Nov 16 '16 at 14:56

Holt

36,600
7
92
139

I suspected that might be the case. Is there a way of creating a `unique_ptr` pointing to an uninitialized array? – Alessandro Power Nov 16 '16 at 14:58
2

@AlessandroPower `std::unique_ptr(new int[100])`. – Holt Nov 16 '16 at 14:59
3

@AlessandroPower but beware of [Differences between std::make_unique and std::unique_ptr](http://stackoverflow.com/q/22571202/673852). – Ruslan Nov 16 '16 at 18:58

Why does unique_ptr instantiation compile to larger binary than raw pointer?

1 Answers1