Delayed constructor in C++

Question

I have been reviewing some code that looks like this:

class A; // defined somewhere else, has both default constructor and A(int _int) defined
class B
{
public:
    B(); // empty
    A a;
};

int main()
{
     B* b;
     b = new B();
     b->a(myInt); // here, calling the A(int _int) constructor,
     //but default constructor should already have been called
}

Does this work? Calling a specific constructor after the default has already been called?

Answer 1

That code does not call a's constructor. It calls A::operator()(int).

But if you explicitly call a constructor on an object that has already been constructed, you're well into undefined behavior-land. It may seem to work in practice, but there is no guarantee that it'll do what you expect.

Answer 2

This is not calling the constructor, and this answer covers the only possible explanation for what is happening.

The only standard way to call a constructor on an existing object is to use placement new, (after the previous instance has been destructed):

void foo (A * a) {
  a->~A ();           // Destroy previous instance
  new (a) A(myInt);   // Construct new object in same location
}

Answer 3

you can make another constructor in Class B

B(int _int):a(_int) {}

in that case when you write b = new B(myInt);

Above code will not delay your constructor code of class A.

you dont need to call b->a(myInt)

Answer 4

You should just call the A(int) constructor from within the B() constructor or make a B(int) constructor that also calls the A(int) one.

The best practice is to have both, the default one to setup a default int for A, and the B(int) one to init A(int).