Is it possible to invoke the function of a class based on the fact that it is the only public one ? What I mean:
Something like:
double res = MyClass().myFunction(n);
becomes
double res = MyClass()[0](n);
Ideally I would have liked to call the function using a string with its name:
double res = MyClass().reflection("myFunction")(n);
But it seems not possible without wasting at least twice the ink to write the function name (function pointer and corresponding string in a map).
You can overload the call operator of the class. This is commonly called a Functor:
class MyClass {
public:
int operator()(int param) const {
return functionName(param);
}
int functionName(int param) const { return param; }
};
MyClass c;
int returnVal = c(3);
Edit addressing const comment:
The function and operator do not need to be const. You should mark functions const whenever the function does not modify the state of the object. This gives more information to people calling the function and is particularly important in multi-threaded applications. If the function you are calling is not const you can remove the const from the overload.
See this for more info.
int param with any arguments you want. It works just like a function. You can call other functions from there as well.
error: passing ‘const MyClass’ as ‘this’ argument discards qualifiers [-fpermissive] 
const std::string&, which is used then to translate to the actual function call (e.g. using a std::map<std::string,std::function<void()>. If you need additional (input / output) parameters add them as needed, but you must have a function / operator call signature, which fit's for all the functions you want to call that way. C++ deosn't really support reflection.You can get something close to what you wrote by overloading the [] operator:
#include <iostream>
class MyClass
{
public:
double operator [] (int n)
{
return functionName (n);
}
private:
double functionName (int n)
{
return n + 1;
}
};
int main ()
{
int n = 1;
double res = MyClass ()[n];
std::cout << "res: " << res << std::endl;
return 0;
}
See the result here.
Notice tha here, the parameter passed to [] is shown to be of size_t, but I don't think that is a requirement by the standard. I was able to make it work for std::string as well.
#include <iostream>
#include <string>
class MyClass
{
public:
std::string operator [] (std::string n)
{
return functionName (n);
}
private:
std::string functionName (std::string n)
{
return n + '1';
}
};
int
main ()
{
std::string n = "test";
std::string res = MyClass ()[n];
std::cout << "res: " << res << std::endl;
}
See here
size_t as the parameter, but that is just a convention because of what the operator is usually used for (indexing into containers). That is not required by the language standard.std::map<KeyType,ValueType> once was instantiated with the type std::string as KeyType ;-) And the same for the call operator overload operator()(const std::string& fnName) BTW.