Hello there dear forum.

So my question is about class inheriences and virtual functions.

so lets say I got a class structure as following

class A{

A();
~A();

virtual void f(){ //does w/e }

};

class B : public A{

B();
~B();
void f(){ //does something diffrent }
};

main(){

B object;
}

so first thing is, in what order do constructers/deconstructers get called :o ? As far as I understand the constructurs are builed from the base up meaning the constructor of A will get called and then the constructor of B and deconstructers are the opposite, meaning B's deconstructor first and then A's. Am I right o.o ?

The main question tho once I "overload" the virtual function in the child class does the base's class function still get called or only the function in B. ( once I actually call the function ofc).

P.S all under the asumption I am creating only a object of B and no objects of A are used.

Thanks in advance ^^ <3

Remember to mark all destructors as virtual or the base class destructors will not be called.

Thanks alot for the answer guys really cleared thigns up they were really helpful :o !

Now I just have 1 follow up question, if I dont overide the virtual f() function in my child class, can I still call the original f() function ( defined in the base class ) through my child object ( the B object in my example )

Yes, you can still call it even if a derived class doesn't override it.

You can make a non-virtual call from within a virtual function though which is sometimes needed (not for destructors though, which automatically call the base class destructors)

e.g.

class Base
{
public:
    virtual void f() { cout << "Base::f" << endl; }
};

class Derived : public Base
{
public:
    void f() // is still virtual
    {
        cout << "Derived::f" << endl;
        Base::f();  // call base class implementation from derived class explicitly
    }
};

That was hell of useful as well, thanks so much for the tip :o !

You shouldn't ever call virtual functions in a constructor or destructor as the dispatch might not be correct for what you want it to do.

Unless, of course, static dispatch is what you want it to do. It's simple enough to understand that constructors and destructors treat all calls to their own member functions as non-virtual.

For the curious, here's why: To help ensure that member functions are only being called on initialized objects in valid states, C++ has a guiding principle that no class member function should be called before the constructor of the class is called or after the destructor of the class has run.

During execution of a base class constructor, the derived class constructor has not yet been called, and during execution of a base class destructor, the derived class destructor has already been run. So it would be a violation of the above principle if the base class constructor or destructor could call any derived class members.

Virtual function calls would allow exactly that, so within constructors and destructors, calls to the object's member functions are all treated as non-virtual.

The way I like to think of it is that during execution of a base class constructor, the object being constructed is not yet a derived type object. The derived class's constructor has not yet been called and so the derived class's functions are not yet accessible. Similarly, during execution of a base class destructor, the object being destructed is no longer a derived type object. The derived class's destructor has already run and so the derived class's functions are no longer accessible.