Is there an implicit default constructor in C++?

Question

In the book I'm reading at the moment (C++ Without Fear) it says that if you don't declare a default constructor for a class, the compiler supplies one for you, which "zeroes out each data member". I've experimented with this, and I'm not seeing any zeroing -out behaviour. I also can't find anything that mentions this on Google. Is this just an error or a quirk of a specific compiler?

Answer 1

C++ does not guarantee zeroing out memory. Java and C# do (in a manner of speaking).

Some compilers might, but don't depend on that.

Answer 2

C++ does generate a default constructor but only if you don't provide one of your own. The standard says nothing about zeroing out data members. By default when you first construct any object, they're undefined.

This might be confusing because most of the C++ primitive types DO have default "constructors" that init them to zero (int(), bool(), double(), long(), etc.), but the compiler doesn't call them to init POD members like it does for object members.

It's worth noting that the STL does use these constructors to default-construct the contents of containers that hold primitive types. You can take a look at this question for more details on how things in STL containers get inited.

Answer 3

C++ generates a default constructor. If needed (determined at compile time I believe), it will also generate a default copy constructor and a default assignment constructor. I haven't heard anything about guarantees for zeroing memory though.

Answer 4

The compiler will generate default constructors and destructors if user-created ones are not present. These will NOT modify the state of any data members.

In C++ (and C) the contents of any allocated data is not guaranteed. In debug configurations some platforms will set this to a known value (e.g. 0xFEFEFEFE) to help identify bugs, but this should not be relied upon.

Answer 5

Zero-ing out only occurs for globals. So if your object is declared in the global scope, its members will be zero-ed out:

class Blah
{
public:
    int x;
    int y;
};

Blah global;

int main(int argc, char **argv) {
    Blah local;
    cout<<global.x<<endl;  // will be 0
    cout<<local.x<<endl;   // will be random
}

Answer 6

The default constructor created for a class will not initialize built-in types, but it will call the default constructor on all user-defined members:

class Foo
{
public:
     int x;
     Foo() : x(1) {}
};

class Bar
{
public:
     int y;
     Foo f;
     Foo *fp;
};

int main()
{

    Bar b1; 
    ASSERT(b1.f.x == 1); 
    // We know nothing about what b1.y is set to, or what b1.fp is set to.

    // The class members' initialization parallels normal stack initialization.
    int y;  
    Foo f; 
    Foo *fp; 
    ASSERT(f.x == 1);
    // We know nothing about what y is set to, or what fp is set to.

}

Answer 7

If you do not define a constructor the compiler will define a default constructor for you.

The implementation of this

default constructor is:

• default construct the base class (if the base class does not have a default constructor this is a compilation failure)
• default construct each member variable in the order of declaration. (If a member does not have a default constructor this is a compilation failure).

Note:
That POD data (int,float,pointer etc) do not have an explicit constructor but the default action is too do nothing (in the vane of C++ philosophy; we do not want to pay for somthing unless we explicitly ask for it).

If no destructor/copy Constructor/Assignment operator is defined the compiler builds one of those for you (so a class always has a destructor/Copy Constructor/Assignment Operator (unless you cheat and explicity declare one but don't define it)).
The default implementation is:

Destructor:

• If user defined destructor defined execute the code provided.
• Call the destructor of each member in reverse order of declaration
• Call the destructor of the base class.

Copy Constructor:

• Call the Base class Copy Constructor.
• Call the copy constructor for each member variable in the order of declaration.

Assignment Operator:

• Call the base class assignment operator
• Call the assignment operator of each member variable in the order of declaration.
• Return a reference to this.

Note Copy Construction/Assignemtn operator of POD Data is just copying the data (Hence the shallow copy problem associated with RAW pointers).

Answer 8

I think it's worth pointing out that the default constructor will only be created by the compiler if you provide no constructor whatsoever. That means if you only provide one constructor that takes an argument, the compiler will not create the default no-arg constructor for you.

The zeroing-out behavior that your book talks about is probably specific to a particular compiler. I've always assumed that it can vary and that you should explicitly initialize any data members.