Question

C++ type change during deletion

I’ve read that when you construct a derived type, the type changes depending on which constructor is being called. So, if you create a derived object and call a virtual function using a base pointer, normally it would map to the implementation in the derived class. If you called the virtual function in the base class constructor though, it would use the base class implementation as the type of the object is technically that of the base class while in that function. For example (makeshift code, sorry if it doesn’t compile):

class Base { 
    Base()
    {
        std::cerr << "Base Constructor.";
        func();
    }

    virtual void func() {
        std::cerr << "Func base called." << std::endl;
    }
};

class Derived : public Base {
    Derived()
    {
        std::cerr << "Derived Constructor.";
        func();
    }

    void func() {
        std::cerr << "Func derived called." << std::endl;
    }
};

int main() {
    Derived* d = new Derived;
    delete d;
}

Should output:

Base Constructor.
Func base called.
Derived Constructor.
Func derived called.

First of all, is this always true or is it implementation dependent?

If I used RTTI and typeinfo, would the type printed in the base actually be that of the base, or is this more of an unwritten rule sort of situation?

Is it dangerous to call virtual functions from constructors with this in mind, or is it safe as long as you know what you’re doing?

Answer 1

To keep it short and simple, you can have a Rule:

The virtual mechanism is disabled in Constructors and Destructors

A virtual function call in Base class will always call the base class version of the function, the same in derived class results in call to the Derived class version of the function.

First of all, is this always true or is it implementation dependent?

Yes this is always true. This is not implementation-dependent.

If I used RTTI and typeinfo, would the type printed in the base actually be that of the base?

Yes it would be of Base; Derived object doesn’t even exist while you are in Base class constructor.

Is it dangerous to call virtual functions from constructors with this in mind, or is it safe as long as you know what you’re doing?

No it is not dangerous to call virtual functions from constructor as long as you understand the semantics behind it.

---

This C++ FAQ should be a good read for you.