`Base *b = new Base;` vs `Base *b = new Base();` without defining my own constructor

Question

If I don't define my own constructor is there any difference between Base *b = new Base; vs Base *b = new Base(); ?

Answer 1

Initialization is kind of a PITA to follow in the standard... Nevertheless, the two already existing answers are incorrect in what they miss, and that makes them affirm that there is no difference.

There is a huge difference between calling new T and new T() in classes where there is no user defined constructor. In the first case, the object will be default-initialized, while in the second case it will be `value-initialized*. If the object contains any POD subobject, then the first will leave the POD subobject uninitialized, while the second will set each subelement to 0.

struct test {
   int x;
   std::string s;
};
int main() {
   std::auto_ptr<test> a( new test );
   assert( a->s.empty() ); // ok, s is string, has default constructor
                           // default constructor sets it to empty
// assert( a->x == 0 );    // this cannot be asserted, the value of a->x is
                           // undefined
   std::auto_ptr<test> b( new test() );
   assert( b->s.empty() ); // again, the string constructor sets to empty
   assert( b->x == 0 );    // this is guaranteed by *value-initialization*
}

For the long road... default-initialize for a user defined class means calling the default constructor. In the case of no user provided default constructor it will call the implicitly defined default constructor, which is equivalent to a constructor with empty initialization list and empty body (test::test() {}), which in turn will cause the default initialization of each non-POD subobject, and leave all POD subobjects uninitialized. Since std::string has a user (by some definition of user that includes the standard library writer) provided constructor, it will call such constructor, but it will not perform any real initialization on the x member.

That is, for a class with user provided default constructor, new T and new T() are the same. For a class without such a constructor, it depends on the contents of the class.