Thread: Calling virtuals inside constructors

I do not think that there is a solution, and I also think that requiring that derived classes implement an Init member function instead of having the option to directly initialise in the constructor is not necessarily a good thing.

I think what Laserlight is saying is that since A() calls Init, which is not valid if B does not in itself implement an Init. You should have a minimal (empty) Init() inside the A class.

Further, the "solution" to calling virtual functions in the constructor is to not call them from the constructor - a two-stage construction is needed, where you construct the class first, then call the Init() AFTER the class has been constructed. You may want to have some sort of checking mechanism (in debug builds at least) that checks that Init is called on the constructed object before it is being used - e.g. set a bool initialized to true when Init ends (at the end in case of exceptions during the "middle" part).

--
Mats

You might consider something like:

Code:

class A
{
public:
   A( ) {}
};

class B : public A
{
  void Init() {}
public:
  B() { Init(); }
};

Now you cannot guarantee that all constructors use an Init method but it is not clear to me why this should be mandatory. The purpose of constructors is to initialize the class itself but this can be done in various ways. Also each base class initalizes itself in its constructor, rather than attempt to initialize its descendants.

That or use two-stage constructor if an Init() method is really needed.

Originally Posted by matsp

I think what Laserlight is saying is that since A() calls Init, which is not valid if B does not in itself implement an Init. You should have a minimal (empty) Init() inside the A class.

My interpretation is different. The base class and derived class constructors should just do the work of initialisation. Then it is up to the programmer to decide, for each class, how that is achieved. But calling a virtual function is not one of the preferred options.

Originally Posted by matsp

Further, the "solution" to calling virtual functions in the constructor is to not call them from the constructor - a two-stage construction is needed, where you construct the class first, then call the Init() AFTER the class has been constructed.

That's actually quite hideous in practice: too many opportunities for the programmer to forget to call the Init() function or (sometimes worse) to call it more than once.

Originally Posted by matsp

You may want to have some sort of checking mechanism (in debug builds at least) that checks that Init is called on the constructed object before it is being used - e.g. set a bool initialized to true when Init ends (at the end in case of exceptions during the "middle" part).

That's just a hack to get around a design that is flawed anyway.

I'm by no means saying that two-stage construction is actually a "good" idea. It is a solution that can be used if it's required, but I agree, there's probably something a bit wrong with the design if you need to do that. I should have made that clearer in my original post.

And if you HAVE to use this method, then I still think it's a good idea to have checks to DETECT the programmer getting it wrong - Init() can also check the bool variable to spot multiple Init calls - but that is indeed a bandage holding the wheel in place, and a better solution would be to design out the need to do this sort of thing. There are several solutions to the problem - the simplest one is to simply not make Init() a virtual function, but let each class that feels a need to have one have it's own private Init() function - the base class's Init function will be called by the base-class constructor, which is automatically called by the derived constructor.

There may be situations when there is a GENUINE need to call a virtual function of a derived class from the base-class during some sort of post-construction initialization, but in general, it's probably WRONG when this is happening.

--
Mats

What I meant was that I believe that constructors should be used to perform initialisation. Sure, sometimes it makes sense to delegate some of the work to a helper function, but that would depend on the situation. I am not in favour of two phase construction if it can be avoided.

One other thing that should work would be to create a function that creates an object of the type you want and then calls Init() on it and returns that object. You could even make it a static member variable called something like CreateObj() and make the constructors private to force people to use the CreateObj() function if they want an instance of the class... I believe that's the Factory design pattern.

Originally Posted by cpjust

One other thing that should work would be to create a function that creates an object of the type you want and then calls Init() on it and returns that object. You could even make it a static member variable called something like CreateObj() and make the constructors private to force people to use the CreateObj() function if they want an instance of the class...

The downside of that is that the CreateObj function needs to be modified every time you introduce a new class to the hierarchy .... specifically, the part of the function that creates the object. It also doesn't necessarily work all that cleanly unless the objects are created dynamically (eg with operator new).

Easier to just put the logic into constructors, and create an object of required type.

Originally Posted by cpjust

I believe that's the Factory design pattern.

What you describe is not the factory design pattern. Although it is true that a function who's purpose is to create objects is often called a "factory method" or "factory function".