C++ : What is happening when a non-overridden calls a overridden method?

Question

The version of a overridden method that gets invoked depends on if you care calling the function "through" the base class or "through" the derived class. However, I am finding if I call a non-overridden method, and the overridden method calls some function that is overridden, then the base class version is still called, even though I am accessing the instance through pointer to the derived class. Could someone explain why this happens?

CODE:

class Base {
public:
    void display() {
        foo();
    }
    void foo() {
        cout << "Base.foo()" << endl;
    }
};

class Derived : public Base {
public:
    void foo() {
        cout << "Derived.foo()" << endl;
    }
};

int main() {
    Derived* derived = new Derived();
    derived->display();
    while (true) {}
}

You are not overriding these functions because they are not `virtual` — Neil Kirk, Oct 25 '15 at 20:02

score 6 · Answer 1 · answered Oct 25 '15 at 20:04

the base class version is still called, even though I am accessing the instance through pointer to the derived class. Could someone explain why this happens?

Although you call method via pointer to derived class, your method is not virtual, so static dispatch is used, so Base::display() calls Base::foo() directly, even if it is overridden in subclasses. To achieve behavior you want, you must use dynamic dispatch, i.e. mark your methods as virtual.

class Base {
public:
    void display() {
        foo();
        bar();
    }
    void foo() {
        cout << "Base.foo()" << endl;
    }
    virtual void bar() {
        cout << "Base.bar()" << endl;
    }
};

class Derived : public Base {
public:
    void foo() {
        cout << "Derived.foo()" << endl;
    }
    virtual void bar() {
        cout << "Derived.bar()" << endl;
    }
};

int main() {
    Derived* derived = new Derived();
    derived->display();
}

Output:

Base.foo()
Derived.bar()

score 1 · Answer 2 · edited May 23 '17 at 10:27

The thing is: you do not have overridden any function; you have hidden its name.

In C++, only virtual functions (see C++ FAQ) can be overridden. Making the Base::foo() virtual yields the expected result: (run code!)

class Base {
public:
    void display() {
        foo();
    }
    virtual void foo() {
        cout << "Base.foo()" << endl;
    }
};

class Derived : public Base {
public:
    void foo() {
        cout << "Derived.foo()" << endl;
    }
};

int main() {
    Derived* derived = new Derived();
    derived->display();
}

score 0 · Answer 3 · answered Oct 25 '15 at 20:00

virtual qualifier needs to be used for methods that need to be overridden.
ex:
 class Base {
public:
    void display() {
        foo();
    }
    virtual void foo() {
        cout << "Base.foo()" << endl;
    }
};

class Derived : public Base {
public:
    virtual void foo() {
        cout << "Derived.foo()" << endl;
    }
};

int main() {
    Derived* derived = new Derived();
    derived->display();
    while (true) {}
}

score 0 · Answer 4 · answered Oct 25 '15 at 20:08

You are not using a virtual function.

An object in a class hierarchy has two types: It's "real" class, and the class that the compiler thinks at the moment that it has.

When you call a virtual function, the compiler always calls the function that belongs to the "real" class. When you call a non-virtual function, the compiler calls the function belong to the class that it thinks is the objects class.

While executing code in a subclass, the compiler thinks that *this is an object of the subclass. Therefore calling a non-virtual function will call the function belonging to that subclass.

C++ : What is happening when a non-overridden calls a overridden method?

4 Answers4