Are empty constructors always called in C++?

Question

I have a general question, that may be a little compiler-specific. I'm interested in the conditions under which a constructor will be called. Specifically, in release mode/builds optimised for speed, will a compiler-generated or empty constructor always be called when you instantiate an object?

class NoConstructor  
{  
    int member;  
};  

class EmptyConstructor  
{  
    int member;  
};

class InitConstructor  
{  
    InitConstructor()  
        : member(3)   
    {}  
    int member;  
};

int main(int argc, _TCHAR* argv[])  
{  
    NoConstructor* nc = new NoConstructor(); //will this call the generated constructor?  
    EmptyConstructor* ec = new EmptyConstructor(); //will this call the empty constructor?  
    InitConstructor* ic = new InitConstructor(); //this will call the defined constructor  

    EmptyConstructor* ecArray = new EmptyConstructor[100]; //is this any different?
}

I've done a lot of searching, and spent some time looking through the generated assembly code in Visual Studio. It can be difficult to follow in release builds though.

In summary: Is the constructor always called? If so, why?

I understand this will very much depend on the compiler, but surely there's a common stance. Any examples/sources you can cite would be really appreciated.

If you don't mind my asking, is this just idle curiosity or does the quality of your finished product hinge on whether or not the compiler optimizes for this? — Blrfl
– Blrfl, Commented Feb 23, 2011 at 22:13
A little of both. I'm writing an array class (as an exercise) that uses something similar to boost::is_pod<> to decide whether or not to use a template specialisation with an implementation that uses memswap/memcopy, rather than explicitly calling constructors/destructors/assignment operators. It got me wondering about how much of an impact this would actually have on performance for pod types. — JBeFat
– JBeFat, Commented Feb 23, 2011 at 22:20
I hope you're not dynamically allocating like that in your real program. — GManNickG
– GManNickG, Commented Feb 24, 2011 at 1:22

Konrad Rudolph · Accepted Answer · 2011-02-23 22:17:33Z

15

will a compiler generated constructor/empty constructor always be called when you instantiate an object?

No. If your class is a so-called “POD” (plain old data) then the compiler-generated constructor won’t always be called.

Specifically, it won’t be called in the two following cases:

struct Pod {
    int x;
};

int main() {
    Pod pod;
    std::cout << pos.x << std::endl; // Value undefined.

    Pod pod2 = Pod(); // Explicit value initialization.


    Pod* pods = new Pod[10];
    // Values of `pods` undefined.

    Pod* pods2 = new Pod[10](); // Explicit value initialization.
}

The conditions for when exactly a type is a POD are a bit tricky. The C++ FAQ has a nice breakdown.

edited Feb 23, 2011 at 22:17

answered Feb 23, 2011 at 21:50

Konrad Rudolph

549k142 gold badges967 silver badges1.3k bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

JBeFat Over a year ago

This is a good answer. Thanks Konrad :). My follow up question would be - if an object doesn't have an explicit (user defined) constructor, why would the compiler not always optimise it out (Assuming the class didn't contain any member objects that define constructors)? Did I just give a vague definition of a pod type?

Lara Bailey Over a year ago

Pod* pods2 = new Pod[10](); // Explicit constructor call. This comment isn't correct, there are no constructor calls. () calls for value initialization which happens instead of a constructor call. An implicitly defined default constructor would leave the member x uninitialized. Similarly in Pod pod2 = Pod();, while it's true that there is a constructor call, it's only the copy constructor that is called.

Lara Bailey Over a year ago

@KonradRudolph: Strictly, because it lacks a user-declared default constructor. It's POD-ness isn't relevant for value-initialization.

Loki Astari Over a year ago

But: Explicit value initialization is basically the POD equivalent of calling a constructor. And I though it was zero-initialization. But don't have the standard handy to read.

Lara Bailey Over a year ago

@MartinYork: No, value-initialization only distinguishes between classes with or without a user-declared constructor. POD-ness isn't important for value-intialization; it is important for default-initialization.

|

Erik · Accepted Answer · 2011-02-23 21:49:29Z

10

Logically, the constructor is called. In generated code, if the constructor does nothing, there will be no instructions that can be traced back to the constructor, unless your compiler is very very bad at optimizing and inserts a call to something that just returns.

answered Feb 23, 2011 at 21:49

Erik

91.8k13 gold badges203 silver badges192 bronze badges

9 Comments

JBeFat Over a year ago

I suspected this, but I'm having trouble proving/verifying it. Do you have any references to support this, or perhaps some example disassemly?

Erik Over a year ago

Any proof would be dependent on compiler and flags, and not really a proof as you can't cover every possible case by testing. Which compiler do you use?

JBeFat Over a year ago

Currently MSVC9. Any tips on how to test this behaviour would be awesome!

Erik Over a year ago

It's pretty clear from VC9's mixed source/disassembly window that there's no call to empty ctors... Not sure how to demonstrate it otherwise.

Lara Bailey Over a year ago

@Erik: A constructor isn't called (even logically) when a object of class type that has no user-declared default constructor is value-initialized which applies in half of the cases in the question.

|

score 5 · Accepted Answer · 2011-02-23 22:05:45Z

5

When in optimizing mode, if your class or structure is POD (has only POD types) and constructor is not specified, any production quality C++ compiler will not only skip the call to a constructor but not even generate it.

If your class has non-POD members who's constructor(s) have to be called, compiler will generate default constructor that calls member's constructors. But even then - it will not initialize POD types. I.e. if you don't initialize member explicitly, you may end up with garbage there.

The whole thing can get even fancies if your compiler/linker has LTO.

Hope it helps! And make your program work first, then use a profiler to detect slow places, then optimize it. Premature optimization may not only make your code unreadable and waste tons of your time, but could also not help at all. You have to know what to optimize first.

Here is a disassembly for code in your example (x86_64, gcc 4.4.5):

main:
    subq    $8, %rsp
    movl    $4, %edi
    call    _Znwm
    movl    $4, %edi
    movl    $0, (%rax)
    call    _Znwm
    movl    $4, %edi
    movl    $0, (%rax)
    call    _Znwm
    movl    $400, %edi
    movl    $3, (%rax)
    call    _Znam
    xorl    %eax, %eax
    addq    $8, %rsp
    ret

As you can see, there are no constructors called at all. There are no classes at all, every object is just a 4 bytes integer.

With MS compiler, YMMV. So you have to check disassembly yourself. But result should be similar.

Good luck!

edited Feb 23, 2011 at 22:05

answered Feb 23, 2011 at 21:58

user405725

2 Comments

JBeFat Over a year ago

Awesome answer. Thanks! I actually spent quite a bit of time checking the disassembly. I wasn't actually satisfied that the resulting assembly (similar to what you've listed above) was proof that the constructor wont be called. What if I allocate 100 of these objects, from some other class? Surely the compiler wouldn't simply try to push the data onto the stack. That's where things got tricky and I thought I'd ask here... :)

user405725 Over a year ago

@JBeFat: In that case compiler will align data (unless packing is turned on) and allocate chunks of appropriate size. But constructor still will not be called.

Zan Lynx · Accepted Answer · 2011-02-23 21:50:50Z

1

Certain class or struct types are called POD "Plain Old Data" in C++. These types will not have constructors called.

The rules for being a POD are important enough that you should look them up, but in summary: only contains primitive data types and has no defined constructors.

answered Feb 23, 2011 at 21:50

Zan Lynx

54.7k11 gold badges85 silver badges135 bronze badges

Comments

Andrey · Accepted Answer · 2011-02-23 22:10:33Z

0

Your sample isn't very good, you've missed the public keyword in sample classes and moreover in your examples force zero-initialization by writing CLASS * class = new CLASS(); instead of CLASS * class = new CLASS;.

In the code as you put it - zero-initialization will always be performed as it is required by the standard. You can call it as you want - but there WILL be code to guarantee the rules of the standard.

If you had asked without showing this controversial sample code - then the only correct answer would be - compiler specific.

answered Feb 23, 2011 at 22:10

Andrey

4,3961 gold badge28 silver badges33 bronze badges

3 Comments

JBeFat Over a year ago

The code was typed in a browser window. It may not compile but it gets the point across. The question is compiler specific, but it seems like behaviour that would be fairly standard across compilers. What do you mean by zero initialisation? This isn't really a helpful answer, but thanks for taking the time to reply :)

Andrey Over a year ago

as I was writing - a number of better replies have appeared :) I meant that new DUMMY and new DUMMY() are different things. The last one forces initialization - a trick frequently used to zero-initialize PODs.

Andrey Over a year ago

btw, good question. We can expect a lot of discussions of what seems or does not seem to be "constructor call" )

Collectives™ on Stack Overflow

Are empty constructors always called in C++?

5 Answers 5

6 Comments

9 Comments

2 Comments

Comments

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

6 Comments

9 Comments

2 Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related