C++ construction: "MyClass c" is bad, "MyClass c = MyClass()" is slow, I want "MyClass c()"

Question

Here's some code:

class MyClass
{
public:
    int y;
};

int main()
{
    MyClass item1;
    MyClass item2 = MyClass();
}

When I run this, I receive the following values:

item1.y == [garbage]
item2.y == 0

Which, well, surprises me.

I expected item1 to be default-constructed and item2 to be copy-constructed off an anonymous default-constructed instance of MyClass, resulting in both equaling 0 (since default-constructors initialize members to default values). Examining the assembly:

//MyClass item1;
//MyClass item2 = MyClass();
xor         eax,eax  
mov         dword ptr [ebp-128h],eax  
mov         ecx,dword ptr [ebp-128h]  
mov         dword ptr [item2],ecx  

Shows item2 being constructed by writing a '0' value somewhere temporary and then copying it into item2, as expected. However, there's NO assembly for item1.

So, the program has memory for item1 in the stack but it never constructs item1.

I can appreciate wanting that behavior for speed purposes, but I want the best of both worlds! I want to know item1.y == 0 (it gets constructed), but I don't want to waste time on default-construct-anonymous-instance-then-copy-construct like item2 does.

Frustratingly, I can't force a default-construct by saying MyClass item1(); since that is interpreted as a function prototype.

So... if I want to use the default constructor on item1 without also copy-constructing, how the heck do I do that?

Side-note: it looks like if I declare a constructor for MyClass, item1 is constructed as usual. So this behavior only applies to compiler-generated constructors.

Answer 1

Make your class look like this:

class MyClass 
{
public:
    MyClass() : y(0) 
    {
    }

public:
    int y;
};

and both examples will work fine. Your problem is that if no constructor is supplied, the basic type members will not be initialized. So y is representing whatever random data happens to be on the stack in the spot where item1 is residing.

Explicitly implementing a constructor addresses this.

The behavior exists because of C++'s "you only pay for what you use" mentality. Basic types don't have a "default value" as that would make it unnecessarily (slightly) more costly to allocate something and then fill it in later due to the values effectively being set twice. Once for the "default value", once for the value you actually wanted.

Answer 2

In C++ you only pay for what you ask to be done. The ability to have types that do not initialize their data can be an important performance boost: annoyingly, this is also the default behavior, because it was inherited from C.

You can fix this by creating a constructor that zero initializes the int, by using {} uniform initialization syntax, or by using the new default syntax int y = 0; in the type declaration (the last requires C++11, the second requires C++11 if the type is non-POD).

Your performance concerns about Foo f = Foo(); are mislead by examining debug build assembly. Copy elision in such a trivial case is supported by every non brain dead compiler on the market, and is legal even if the ctor has side effects.

Answer 3

The trouble is your misinterpretation of two things.

1. What the compiler generated default constructor does.
2. What is a declaration is (and thus when assignment is used).

What the compiler generated default constructor does.

If you do not define a constructor the compiler will generate a default constructor for you. But there are two different version. A 'Value-Initialization' default constructor (which for built-in POD types does nothing and leaves them uninitialized). A 'Zero-Initialization' default constructor (which for built-in POD types sets them to zero).

What is a declaration is (and thus when assignment is used).

The assignment operator only applies when the object on the left hand side of the = has been fully constructed. Since the object in a declaration is not fully constructed until the ';' this is not an assignment.

Bar x = Bar(); // There is no assignment here (this is a declaration using the default constructor
Bar y = Bar(2);// There is no assignment here (this is a declaration using a constructor).

This is construction of an object from a temporary using the copy constructor. But that does not matter because the compiler just elides the actual copy and builds in place so I would be totally surprised if there was any copy happening.

What is happening in your code

int  x;          // default-Inititalized.      [ Value = Garbage]
int  z = int();  // Zero-Inititalized.         [ Value = 0]

The same rules apply to classes with compiler generated default constructors:

LokiClass  xL;               // Value-Initialized -> Default Initialized
                             //                     This is an explicit call to 
                             //                     the default constructor but  
                             //                     will only Value-Initialize
                             //                     class types and not initialize
                             //                     built-in POD types. 
LokiClass  yL = LokiClass(); // Zero-Initialized    This is an explicit call to 
                             //                     the default constructor but  
                             //                     makes sure to use the 
                             //                     Zero-Initialization version if
                             //                     it is the compiler generated 
                             //                     version.

LokiClass  y1L {};           // C++11 version of Zero-Initialization constructor used.

LokiClass  zL((LokiClass()));// This is copy construction
                             // Which will probably lead to copy elision by the compiler.

So what is the difference between Value/Zero Initialization?
Value Initialization will do no initialization for built in POD types. It will call the Value Initialization compiler generated default constructor on any base classes and members (Note if you define a default constructor then it will use that because there is no compiler generated one).

Zero Initialization will do zero initialization on POD types. It will call the Zero-Initialization compiler generated default constructor on any base classes and members (Note if you define a default constructor then it will use that because there is no compiler generated one).

Answer 4

You can simply do:

MyClass item1;

It may or may not zero initialize the POD type depending on the variable.

Or if you use C++11, you can do:

MyClass item1 {};

to explicitly call the default constructor.

The reason why there is no assembly code for item1 is because the compiler thinks it is not necessary to generate code for a class like the one shown since it has no explicit default constructor written by you.