How to call virtual functions of a derived class through base class pointers, assuming functions in base class are not virtual

Question

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

class Derived : public Base
{   
    public:
    virtual void f()
    {
        Base::f();
    } 
    virtual void g()
    {
        cout<<"derived";
    } 
};

int main()
{
    Base *pBase = new Derived;
    pBase->f();
    return 0;  
}

In this program I have kept both derived and base class functions as virtual. Is it possible call virtual functions of derived class through base class pointer and base class functions are not virtual.

Thanks in advance..

Answer 1

assuming functions in base class are not virtual
This can be achieved via type erasure. But there are caveats.
Your "base" class should decide between the two:

1. Being a view class (can't be called delete on or created by itself)
2. Being a resource owning class (implemented similar to 1, but stores a smart pointer).

Here is an example for case 1: https://godbolt.org/z/v5rTv3ac7

template <typename>
struct tag{};

class base
{
public:
    base() = delete;

    template <typename Derived>
    explicit base(tag<Derived> t)
        : _vTable(make_v_table(t)) 
    {}

    int foo() const { return _vTable.foo(*this); }

protected:
    ~base() = default;

private:
    struct v_table
    {
        virtual int foo(const base &b) const = 0;

    protected:
        ~v_table() = default;
    };

    template <typename Derived>
    static const v_table& make_v_table(tag<Derived>){
        struct : v_table 
        {
            int foo(const base &b) const {
                return static_cast<const Derived&>(b).foo();
            }
        } static const _vTable{};
        return _vTable;
    }

private:
    const v_table& _vTable;
};

class derived : public base
{
public:
    explicit derived()
        : base(tag<derived>{})
    {}

    int foo() const { return 815; }
};

// example
#include <iostream>

int main(){
    derived d{};
    const base& b = d;
    std::cout << b.foo() << '\n';
}

Take notice, that you can only take a pointer or a reference (cv-qualified) to a base class. The base class can't be created on its own.
Also tag<T> is needed to call a templated constructor.

---

DO NOT CALL DERIVED METHODS IN THE BASE CONSTRUCTOR OR DESTRUCTOR

---

Answer 2

Simple answer is no, if the function you are calling is not virtual. The Compiler would have no Idea that you are trying to call a function from the Derived Class, and won't make and I'm paraphrasing here since I do not know the proper term for,"Won't make proper entries in the Virtual Table".

class Base
{   
    public:
    void f() 
    {
        std::cout<<"Base f() Called\n";
        g();
    }
    virtual void g()
    {
        std::cout<<"Base g()\n";
    }
    virtual ~Base(){std::cout<<"Base Destroyed\n";}
};

class Derived : public Base
{   
    public:
    void f()
    {
        g();
    } 
    virtual void g()
    {
        std::cout<<"Derived g()\n";
    } 
    ~Derived(){std::cout<<"Derived Destroyed\n";}
};

int main()
{
    Derived* D1 = new Derived();
    Base* B1 = D1;
    B1->f();
    delete B1;
    return 0;  
}

Have a look at the following code, I have not declared Base::f() as virtual,calling B1->f() calls the Base Method, but the base method calls a virtual function Base::g() and this allows the "Derived" method be called.

Have a look at this thread or this blogpost to understand Virtual Tables.

(1) and you must ALWAYS declare the destructor of a base class virtual when destroying Derived Object through a Base Pointer, else the resources used by the Derived Object will never get destroyed and it's memory will leak until the program closes.

Don't Take my word as gospel, I am simply passing on knowledge I have acquired from first hand experience, Except for (1), specially if you are not using smart pointers