How can I iterate through unknown object methods in C++?

Question

Suppose I have the class

class BaseClass {
  public:
    BaseClass();
    ~BaseClass();
    
    void runAllMethods();
};

and the sub class

class SubClass : public BaseClass {
  public:
    SubClass();
    ~SubClass();

    // arbitrary methods
    void method1();
    void method2();
    ...
};

Suppose I then create the object

SubClass myObject = SubClass();

How do I write runAllMethods() in BaseClass so that it can run all methods of itself, including the methods defined in SubClass (e.g. methods1(), method2(), etc.)? In other words, how do I get a superclass to access the methods in a subclass without knowing the names of the subclass' methods?

Answer 1

How can I iterate through unknown object methods in C++?

As far as I know, this is impossible. Check by reading n3337 (the C++11 standard).

A possible approach is to generate the C++ code running all of them.

You could use some meta-programming approach (like Qt does with its moc, which generates C++ code), or you could use some preprocessor (e.g. GPP) driven by your build automation tool. GNU autoconf might be inspirational.

If you compile your C++ code with GCC, consider extending it with plugins.

You might consider some X-macro tricks.

If your operating system has plugins, you might generate them at runtime then load them. On Linux, see dlopen(3) and dlsym(3) and C++ dlopen mini howto and How to write shared libraries.

On some OSes, ou could use JIT compilation techniques to generate machine code at runtime, like GCC libgccjit enables you. Or use asmjit

Be aware of lambda expressions in C++11. Maybe they could be useful (in addition of other approaches).

Consider also coding in other programming languages (such as Common Lisp; it is homoiconic, but C++ is not) and using clever implementations (e.g. SBCL).

Consider also embedding some interpreter in your C++ program, perhaps Lua or Guile or Python. The interpreted script is then some input to your program and might run whatever code you interface to it. Read the Dragon Book.

Answer 2

Pretty much by using the virtual keyword. See this example:

#include <iostream>

using std::cout;
using std::endl;

class BaseClass {
  public:
    BaseClass() {}
    virtual ~BaseClass() {}

    void method1() { cout << "in superclass" << endl; }

    virtual void runAllMethods()
    {
        method1();
    }
};

class SubClass : public BaseClass {
  public:
    SubClass() {}
    virtual ~SubClass() {}

    void method2() { cout << "in subclass" << endl; }
    
    virtual void runAllMethods()
    {
        BaseClass::runAllMethods();
        method2();
    }
};

int main()
{
    BaseClass* obj = new SubClass;
    obj->runAllMethods();
    delete obj;
}

output:

in superclass
in subclass

This calls the runAllMethods method from the sub class which then again calls the sub class method and the super class runAllMethods.
If you need a slightly different architecture, best is if you state how the code that is to use it later should look like.

In action: http://cpp.sh/2mvvy

Edit: If you want some additional safety here, use override in the subclass:

virtual void runAllMethods() override

This warns you if the method does not actually override (like if you would have a parameter and you change it's type in the super class but not in the sub class, causing the methods to have different signature and thus won't override.)