C++ Inheritance – How to Avoid Calling a Static Function and Call a Base Member Function Instead

c++inheritancestatic

I have a static instance (previously called singleton, but commenters were taking issue with that) of a class which derives from a base class. So far, so good.

Derived has a static function fun, while Base has a member function fun (don't ask). Obviously, calling instance->fun() in Derived::fun() creates an infinite recursion ending in a stack overflow.

I managed to avoid that by calling ((Base*)instance)->fun() instead:

struct Base {
    void fun() { /* ... */ }
};

struct Derived;

static Derived * instance = nullptr;

struct Derived : Base {
    static void fun() {
        // stack overflow!
        // instance->fun();

        // works!
        ((Base*)instance)->fun();
    }
};

int main() {
    instance = new Derived();
    Derived::fun();
}

Is there a better way to avoid calling the static function defined in Derived?

Best Answer

You can call the function instance->Base::fun().

Related Solutions

C++ – How to Call a Parent Class Function from Derived Class

I'll take the risk of stating the obvious: You call the function, if it's defined in the base class it's automatically available in the derived class (unless it's private).

If there is a function with the same signature in the derived class you can disambiguate it by adding the base class's name followed by two colons base_class::foo(...). You should note that unlike Java and C#, C++ does not have a keyword for "the base class" (super or base) since C++ supports multiple inheritance which may lead to ambiguity.

class left {
public:
    void foo();
};

class right {
public:
    void foo();
};

class bottom : public left, public right {
public:
    void foo()
    {
        //base::foo();// ambiguous
        left::foo();
        right::foo();

        // and when foo() is not called for 'this':
        bottom b;
        b.left::foo();  // calls b.foo() from 'left'
        b.right::foo();  // call b.foo() from 'right'
    }
};

Incidentally, you can't derive directly from the same class twice since there will be no way to refer to one of the base classes over the other.

class bottom : public left, public left { // Illegal
};

C++ Templates – How to Check if a Templated Class Has a Member Function

Yes, with SFINAE you can check if a given class does provide a certain method. Here's the working code:

#include <iostream>

struct Hello
{
    int helloworld() { return 0; }
};

struct Generic {};    

// SFINAE test
template <typename T>
class has_helloworld
{
    typedef char one;
    struct two { char x[2]; };

    template <typename C> static one test( decltype(&C::helloworld) ) ;
    template <typename C> static two test(...);    

public:
    enum { value = sizeof(test<T>(0)) == sizeof(char) };
};
    
int main(int argc, char *argv[])
{
    std::cout << has_helloworld<Hello>::value << std::endl;
    std::cout << has_helloworld<Generic>::value << std::endl;
    return 0;
}

I've just tested it with Linux and gcc 4.1/4.3. I don't know if it's portable to other platforms running different compilers.

Best Answer

Related Solutions

C++ – How to Call a Parent Class Function from Derived Class

C++ Templates – How to Check if a Templated Class Has a Member Function

Related Question