Call a classes method using a std::string

Question

Say I have the following class: (possibly meta-generated)

class MyClass
{
    public:
        myMethod(); 
    ...
}

Assuming a few things here:

1.) I have the class name from somewhere (let's pretend)
2.) I have the names of the class methods somewhere ( std::map< std::string, std::function> ... perhaps? )

So...since I may not know the name of myMethod() until runtime, is there a way to call it using a std::string ? This is assuming that I have the names of a class functions stored somewhere.

MyClass example;

std::string funcName{ findMyMethod() };//get std::string name of myMethod

example.someHowRunMyMethodUsing_funcName_();

I know C++ is generally not suited for introspection-like situations, but I'd like to figure this out.

Thanks!

Answer 1

You can do that if you maintain map of std::string -> member function pointers.

std::map<std::string, void (MyClass::*)()> functionMap;
functionMap["myMethod"] = &MyClass::myMethod;

and later

// Get the function name from somewhere.
std::string name = getFunctionName();

// Get the object from somewhere.
MyClass* obj = getObject();

// Check whether there is a function corresponding to the function name.
auto iter = functionMap.find(name);
if ( iter != functionMap.end() )
{
    auto fun = iter->second;
    (obj->*fun)();
}
else
{
    // Deal with missing function.
}

Answer 2

There are many ways, but using a map of member function pointers is probably among the most general for methods with the same signature.

#include <iostream>
#include <map>
#include <string>
using namespace std;

class My_class
{
public:
    void method_1() { wcout << "method_1\n"; }
    void method_2() { wcout << "method_2\n"; }
    void method_3() { wcout << "method_3\n"; }
};

auto method_name() -> string { return "method_3"; }

auto main() -> int
{
    map<string, void (My_class::*)()> methods =
    {
        { "method_1", &My_class::method_1 },
        { "method_2", &My_class::method_2 },
        { "method_3", &My_class::method_3 },
    };

    My_class example;
    (example.*methods.at( method_name() ))();
}

Supporting different signatures is much harder.

Then you would essentially be into DIY runtime type checking.

Answer 3

There is no built-in generic way to do this in C++.

The closest you can do is use virtual functions in C++ to achieve "late binding" however in that case you need to just through a lot of hoops.

http://www.thegeekstuff.com/2013/06/cpp-virtual-functions/

It is not as flexible as "call by name" that higher level languages like Ruby support.

In a dynamic library / module context you have a few more options using functions like dlopen but these are easier to use in C.

http://linux.die.net/man/3/dlopen

Answer 4

There is COM IDispatch interface, that implements exact the same functionality, so you could create you own analog of this interface and use it with your class.

interface IMyDispatch
{
public:
   virtual bool Invoke(const std::string, void*) = 0;
   virtual ~IMyDispatch() {};
};

///...

class CSomeClass : public IMyDispatch
{
public:
  void DoSomeCoolStuff() { /*some cool stuff here*/ };
public: //IMyDispatch
  bool Invoke(const std::string szName, void* pData)
  {
     if(szName == "DoSomeCoolStuff") //or methods map from the other ansvers
     {
        DoSomeCoolStuff();
        return(true);
     }

     return(false);
  }
}

int main()
{
  CSomeClass *pCl;
  IMyDispatch* pDisp = dynamic_cast<IMyDispatch*>(pCl);
  if(pDisp)
    pDisp->Invoke("DoSomeCoolStuff", nullptr);
}