Printable View
I looked. I really did. Anyway...
Is it possible in c++ to call a function the name of which is contained in a variable?
Psuedo code (which is a euphemism for I can't write code that works):
ThanksCode:double MYROUTINE(double x){
// do stuff
}
double MYBOSSESROUTINE(const char* z)
{
// value of z is "MYROUTINE"
call z // <== obviously that doesn't work
}
John
You can use function pointers.
Code:typedef double (*SOME_FN)(double);
double MYROUTINE(double x) {
// do stuff
}
double MYBOSSESROUTINE(SOME_FN z)
{
return z(1.0);
}
int main(void)
{
MYBOSSESROUTINE(MYROUTINE);
}
I can't change the signature of MYBOSSESROUTINE from:
double MYBOSSESROUTINE(const char* z)
to
double MYBOSSESROUTINE(SOME_FN z)
All I'm allowed to do is pass him a string with the name of my function.
On Windows you would use GetModuleHandle()/GetProcAddress(). On Linux you would use dlopen()/dlsym(). The function in question must be exported dynamically for it to work.
Whoosh! That was the sound of your solution wizzing past my head.
First, it is a windows environment.
Second, while I can read documentation as good as the next fella, pseudocode (even BROKEN pseudocode that I can test and report the errors) is always appreciated.
I have no problem with the function being exported (if'n I knew how to accomplish that). I imagine that requires a statement something like:
#COMPILERCOMMAND EXPORTME
I'm off to read up on GetModuleHandle()/GetProcAddress().
Thanks
John
there isn't a way to do that natively in the C or C++ language. there is no standard method of introspection, which is what you need. in java for example there are ways to do that.
extending on what bithub said, one way to accomplish that natively is to have a table that associates the function name with the function address in a function pointer, then search for the name and then call the address via the function pointer. the drawback is this means you have to know in advance the names of the functions you want to call so you can put them in the table.
In fact this is what the getmodulehandle/getprocaddress stuff does for you behind the scenes, although that approach doesn't require you to know the names in advance so it is more complete but platform specific.
example
Code:// note : probably won't compile.
typedef double (*SOME_FN)(double);
struct function {
const char *name;
SOME_FN f;
};
function function_list[] = {
{"MYROUTINE",MYROUTINE},
{0,0}
};
SOME_FN find_function_by_name(const char *name)
{
function *p = function_list;
// iterate for an element in function_list that matches 'name' or 'not found'
// ....
// call via the function pointer found
return p->f;
}
double MYBOSSESROUTINE(const char* z)
{
SOME_FN f = find_function_by_name(z);
return (*SOME_FN)(1.0);
}
I'm not having much luck with understanding how to implement the GetModuleHandle()/GetProcAddress() solution.
I appreciate the suggestion of the internal table, it may very well be a compromise between what I originally wanted: a switch statement and a dynamic solution (which my boss wants).
Seems a shame that there isn't a built in mechanism to deal with data matching a process. If I'm working with a WIDGET, then I should be able to say something like DO WIDGET to get my result. Such is life.
I'll keep working with the GetModuleHandle()/GetProcAddress() solution because someday, I want to separate myself from working on or in my boss's function and, at the same time, limit my efforts to that which is within my routine.
I know that your suggestion accomplishes the first half of the goal.
Thanks.
John
Its possible, you just have to implement it. Meaning that you will have something like:Quote:
Originally Posted by JohnAnon
Think that if there was a built in system it will more or less do something like above, just maybe more efficiently.Code:double MYROUTINE(double x){
// do stuff
// register routine
}
double MYBOSSESROUTINE(const char* z)
{
// value of z is "MYROUTINE"
Call(z)(); // or something like that
}
There are a few ways to make this elegant. One is to use std::map. They key will be a string and the value will actually be a function pointer. Then you will do something like:
So you do exactly what you want to do very nicely :)Code://define a function pointer
typedef double (*fnc_ptr)(double x);
//this will be your function registry
std::map<std::string, fnc_ptr> fncRegistry;
//maybe this is not actually needed
double MYROUTINE_A(double x);
double MYROUTINE_A(double x)
{
fncRegistry("MYROUTINE_A", MYROUTINE_A);
//define the function
}
double MYBOSSESROUTINE(const char* z)
{
....
fncRegistry(z)(10.2); //call z
....
}
Note that you can also register functions that belong to a library
so the solution is indeed dynamic. You just have to register all the functions that are going to be used.Code:#include <math.h>
//as above
int main()
{
fncRegistry.insert(std::pair<std::string, fnc_ptr>("cos", cos)); //register
MYBOSSESROUTINE("cos");
}
In other languages there are run-time solutions to get a name of a method. But the cases actually really needed are a few, usually a good design will solve your problems.
Note that the functions has to return double and get one input as double. You can extend this with more code. Note also that if the function is misspelled, it will crash. You can fix this by making a "Call(...)" function that checks if the name exists or not first etc
EDIT: This is sample code. Something might not compile, but you fix this with a few tweaks
Post the code you're trying to use. Is it anything like the example on MSDN? GetProcAddress Function (Windows)Quote:
Originally Posted by JohnAnon
Yes, I'm trying to decipher the code in the example on MSDN. It is late here and it will take me too long to dig out the lines I've interspersed with my other code into a workable display.
I'll try to do that tomorrow.
Thanks for helping.
Here is example code:
The code relies on Boost and C++0x. That means you need Visual C++ 10 or GCC 4.3 or higher.Code:#include <boost/scope_exit.hpp>
typedef double (FncPtr_t)(const char*);
auto hLibrary = LoadLibrary("JohnAnonsLibrary.dll"); // Opens the DLL and returns a handle to it
BOOST_SCOPE_EXIT( (hLibrary) )
{
FreeLibrary(hLibrary); // We must free the library when we're done
}
BOOST_SCOPE_EXIT_END;
auto MyFnc = reinterpret_cast<FncPtr_t>(GetProcAddress(hLibrary, "My function name"); // Find and return a function pointer to the specified function
if (MyFnc == NULL)
; // Failure. Unable to find the specified function.
MyFunc(100.0); // Call the function
// We're done. No need to do anything more. Boost.ScopeExit will take care of freeing the library for us.
Code uses Boost with BOOST_SCOPE_EXIT which is a macro which will basically execute a chunk of code when a function ends. Very handy. If you don't have access to it, you have to call FreeLibrary manually at the end.
You can replace "My function" with a string of your choice. In case it's a std::string, don't forget to call c_str() to get the C-style string.
very nice job......
Unfortunately I'm stuck with VC++2008.
Thanks, anyway.
You know, based on the last few responses, I may have miscommunicated.
I'm not building my own separate dll which my bosses routine will call.
My code is going to be compiled at the same time and into the same dll/exe as his.
Yes, I know this means that I can fiddle with a switch statement in his routine so that the passed value will call the correct routine of mine. But he is maintaining his routine and I'm responsible for maintaining my routines, even though they are in the same stream when compilation takes place.
Sorry if I misled everybody.
Does that make it easier or more difficult?
Look at C_ntua's response then. It has what you're looking for.Quote:
Originally Posted by JohnAnon
I had already done that since it looked both elegant and promising. On my computer, however, std::map returns compiler error "'map' is not a member of 'std'".
Maybe I can get map from another library.
That sort of situation -- multiple developers working on different parts of the code -- is "situation normal" for ANY software project. I have yet to see somebody try to solve the problem by such ideas as "call function via string which names it." Honestly, it sounds completely insane.Quote:
Originally Posted by JohnAnon
Well, I've been called worse.
Well, I'm not sure if it's you or your boss who's lost it.Quote:
Originally Posted by JohnAnon
I guess I'd just like to hear some more detail about your problem and why this was chosen as a solution. I'm afraid we might be standing around discussing which hammer is the best choice for pounding in screws.
At this point, it appears that the hammer almost works, so if you can bear with me for a few iterations, I would appreciate it.
I have solved the std::map problem by adding a #include <map>.
So I try the code:
Defining the function pointer survives the compiler.Code://define a function pointer
typedef double (*fnc_ptr)(double x);
//this will be your function registry
std::map<std::string, fnc_ptr> fncRegistry;
//maybe this is not actually needed [I try with and without this line, of course]
double MYROUTINE_A(double x);
double MYROUTINE_A(double x)
{
fncRegistry("MYROUTINE_A", MYROUTINE_A); // < this line now has the error
//define the function
}
double MYBOSSESROUTINE(const char* z)
{
....
fncRegistry(z)(10.2); //call z
....
}
Establishing the map, aka function registry survives the compiler.
When I add the line above the comment indicating that further code defines the function, the compiler complains with:
error C2064: term does not evaluate to a function taking 2 arguments.
I must admit, putting the line "fncRegistry("MYROUTINE_A", MYROUTINE_A)" *inside* the definition of the function itself puzzles me. If the purpose is to add the information to the registry, one would think you would do it once, not every time the function is called.
In any event, that is where I'm stuck right now. I will continue to massage what I can and ask that if anybody spots the specific issue to please let me know.
brewbuck, I appreciate your point of view, but there are very good reasons (well beyond this one project) where the name of the function [or a portion of the name of the function] will be defined in such a way as to make it subject to input from higher up the food chain (including all the way to the user), so consider this a prototype. Many text based languages have this construct built in. I'm not complaining about the fact that it isn't built-in here, just trying to re-create the capability.
>>fncRegistry("MYROUTINE_A", MYROUTINE_A);
should be
fncRegistry.insert( std::make_pair("MYROUTINE_A", MYROUTINE_A) );
And should be done ONLY once. Ie, put it somewhere in your initialization code.
It looks like someone was half-sleeping when that code was written.
Thanks. I thought that line was misplaced and questioned its efficacy.
I'll try your suggestion as soon as I re-install VS2008. I'm embarrassed to say that I somehow blew it up by merely trying to copy a .cpp file from one project to another. <sigh> But I did want to thank you for the response.
Man that code looks like it's asking for trouble. You should work with your boss to fix it.
Well, trouble is my middle name.
Thanks for sharing.
Adding to the map now works. Thanks for that.
Calling the function still doesn't.
Tried:
fncRegistry(z)(12.08333); //call z
and various offshoots with the word "call", but the compiler comes back with:
error C2064: term does not evaluate to a function taking 1 arguments
The signature of the function is:
double MYROUTINE_A(double x)
which, of course, is why the compiler wants my call statement to resolve to a call with one parameter.
If anybody can spot the error, that would be appreciated.
Post the smallest and simplest program that demonstrates the problem.
EDIT:
My guess is that you should have written:
Code:fncRegistry[z](12.08333);
And, indeed, you would be right! Thanks!!!!!!!!!!!!!!!!!!!!!!!!
Now we will see if I can tie all this spaghetti together.
Thank you, thank you, thank you for that edit!!!
Edit: And the spaghetti now works. Many thanks, again!!!!!!!!