calling function on runtime in c [duplicate] - c

Question

This question already has answers here:
Call a function named in a string variable in C
(12 answers)
Closed 9 years ago.
How can I call a function on the runtime? I'm wondering if I can do that without using an if or a switch to call it,
if(arg[1] == something) //Now what I'm looking for
call_function;
Below is what I'm looking for, which is calling the function print using arg?
#include <stdio.h>
void print()
{
printf("print function called\n");
}
int main(int argc, char *argv[])
{
argv[1] to call the print function
}
So then I can call it like this,
./a.out print

Answer 1

This isn't trivial or automatic. Function names only exist in the language, not in the executing program. You have to supply a mapping from a suitable string constant to the function yourself (or use some existing mechanism like dlsym on Posix). You can refer to the function via a function pointer:
typedef void (void_function)(void);
extern void print(void);
extern void foo(void);
extern void bar(void);
void_function my_little_functions[] = { print, foo, bar };
int main(int argc, char * argv[])
{
if (strcmp(argv[1], "print") == 0) { my_little_functions[0](); }
// ...
}
This is for illustration only; instead of a sequence of conditional statements, you should implement some suitable, function-pointer-valued associative lookup structure.
(In C++, this would be a std::unordered_map<std::string, void_function *>. In C, you have to find your own.)

Answer 2

If you are not looking for a "pure C" solution, then chances are you can use APIs of your OS to do the mapping for you. Under POSIX (this compiles and runs):
#include <stdio.h>
#include <dlfcn.h>
void foo(void)
{
printf("foo\n");
}
void bar(void)
{
printf("bar\n");
}
void baz(void)
{
printf("baz\n");
}
int main(int argc, char *argv[])
{
void *hndl = dlopen(NULL, RTLD_LAZY);
void (*fn)(void) = dlsym(hndl, argv[1]);
if (fn) {
fn();
} else {
printf("Function %s() not found\n", argv[1]);
}
return 0;
}

Answer 3

Well, actually there is a way...
At runtime you could write a .c file containing the functions definitions and in main you would write the call to the function named in argv[1]. Then you could invoke a compiler (gcc-linux or cl-windows or whatever) (via system(command)) to generate an executable. Then you invoke that executable (via system(command)) and voilà job done.
What? I didn't say it's a practical way, I just said it's a way.
Proof that this actually works:
#include <stdio.h>
#include <stdlib.h>
const char file_includes[] = "#include <stdio.h>\n";
const char file_functions[] =
"void print() {\n"
" printf(\"print function called\\n\");\n"
"}\n"
"void print2() {\n"
" printf(\"second print function called\\n\");\n"
"}\n";
const char file_main_prolog[] = "int main() {\n";
const char file_main_epilog[] = " return 0;\n}\n";
int main(int argc, char *argv[]) {
if (argc < 2) {
printf("invalid program arguments\n");
return 1;
}
FILE *fout = fopen("function_call.c", "w");
fprintf(fout, "%s", file_includes);
fprintf(fout, "%s", file_functions);
fprintf(fout, "%s", file_main_prolog);
fprintf(fout, " %s();\n", argv[1]);
fprintf(fout, "%s", file_main_epilog);
fclose(fout);
system("gcc -o function_call function_call.c");
system("./function_call");
return 0;
}
This works under linux with gcc installed. You can run this program with the argument print or print2 and you will get print function called or second print function called respectively.