Can I tell if a C++ virtual function is implemente

Question

I want to be able to tell at run-time if an instance of a class implements a virtual function. For example:

struct Base
{
    virtual void func(int x) { <default behavior here> }
    virtual void func2(int x) { <default behavior here> }
};

struct Deriv : Base
{
    virtual void func(int x) override { <new behavior here> }
};

int main()
{
    Base *d = new Deriv;

    if(implements<Base::func(int)>(d)) // This should evaluate true
    {} 

    if(implements<Base::func2(int)>(d)) // This should evaluate false
    {}
}

I have seen this but it's dated and there might be a something that c++11/14 has to say now: Ways to detect whether a C++ virtual function has been redefined in a derived class

Answer 1

What comes to my mind right now is to have a special "counter" variable, which will take its value based on the implementation and zero if the base-class function is called. I think that this sounds a bit obsolete style though and try to find a better solution in a moment. See the example for now:

    struct Base
    {
        virtual void func(int x, int& implemented) {implemented = 0;}

    };

    struct Deriv : Base
    {
        virtual void func(int x, int& implemented) override {implemented = 1;}
    };

If the functions are void as in your example, you also can use "return codes" - just return implemented value back.

Answer 2

The short answer is: No. And certainly not in a portable manner.

The longer answer: actually, the very goal of polymorphism is to make it indistinguishable to the user where the functionality comes from.

Even if the developer does not write code, the compiler might still generate a dedicated version of the function for the derived class (for better optimization). This would throw off even non-portable implementations that would inspect the virtual tables...

An alternative route, however, would be to throw off C++ automatic run-time polymorphism and instead provide an ad-hoc implementation. If for example you were to provide your own virtual table/pointer mechanism, then you would have more control:

struct VirtualTable {
    typedef void (*FuncType)(void*, int);
    typedef void (*Func2Type)(void*, int);

    FuncType func;
    Func2Type func2;
};

and you could check whether the function pointer is, or is not, equal to the default.