How to call a function by its name (std::string) in C++?

Using a map of standard string to standard functions.

#include <functional> #include <map> #include <string> #include <iostream> int add(int x, int y) {return x+y;} int sub(int x, int y) {return x-y;} int main() { std::map<std::string, std::function<int(int,int)>> funcMap = {{ "add", add}, { "sub", sub} }; std::cout << funcMap["add"](2,3) << "\n"; std::cout << funcMap["sub"](5,2) << "\n"; } 

Even better with Lambda:

#include <functional> #include <map> #include <string> #include <iostream> int main() { std::map<std::string, std::function<int(int,int)>> funcMap = {{ "add", [](int x, int y){return x+y;}}, { "sub", [](int x, int y){return x-y;}} }; std::cout << funcMap["add"](2,3) << "\n"; std::cout << funcMap["sub"](5,2) << "\n"; } 

You can also put your functions into a shared library. You will load such library dynamically with dlopen() and then just make the calls to the functions with a std::string. Here an example:

hello.cpp

#include <iostream> extern "C" void hello() { std::cout << "hello" << '\n'; } 

main.cpp

#include <iostream> #include <dlfcn.h> int main() { using std::cout; using std::cerr; cout << "C++ dlopen demo\n\n"; // open the library cout << "Opening hello.so...\n"; void* handle = dlopen("./hello.so", RTLD_LAZY); if (!handle) { cerr << "Cannot open library: " << dlerror() << '\n'; return 1; } // load the symbol cout << "Loading symbol hello...\n"; typedef void (*hello_t)(); // reset errors dlerror(); std::string yourfunc("hello"); // Here is your function hello_t hello = (hello_t) dlsym(handle, yourfunc.c_str()); const char *dlsym_error = dlerror(); if (dlsym_error) { cerr << "Cannot load symbol 'hello': " << dlsym_error << '\n'; dlclose(handle); return 1; } // use it to do the calculation cout << "Calling hello...\n"; hello(); // close the library cout << "Closing library...\n"; dlclose(handle); } 

compilation:

g++ -fPIC -shared hello.cpp -o hello.so 

and:

g++ main.cpp -o main -ldl 

run:

C++ dlopen demo Opening hello.so... Loading symbol hello... Calling hello... hello Closing library... 

The example was stolen from here. There you can find more detailed explanation on dlopen() and c++

There is another possibility which hasn't been mentioned yet, which is true reflection.

An option for this is accessing functions exported from an executable or a shared library using operating system functions for resolving names to addresses. This has interesting uses like loading two 'contestant' dlls into an 'umpire' program, so that people can slug it out by having their actual codes fight each other (playing Reversi or Quake, whatever).

Another option is accessing the debug information created by the compiler. Under Windows this can be surprisingly easy for compilers that are compatible, since all the work can be off-loaded to system dlls or free dlls downloadable from Microsoft. Part of the functionality is already contained in the Windows API.

However, that falls more into the category of Systems Programming - regardless of language - and thus it pertains to C++ only insofar as it is the Systems Programming language par excellence.

Similar to jav's answer, but loading functions from the current program:

#include <iostream> #include <dlfcn.h> extern "C" void test() { std::cout << __PRETTY_FUNCTION__ << "\n"; } extern "C" void test2() { std::cout << __func__ << "\n"; } void something_the_user_is_not_supposed_to_call() { std::cout << "Oops...\n"; } int main(int argc, char** argv) { if (argc < 2) { std::cout << "Usage: " << argv[0] << " [function_name]\n"; return 1; } void* self = dlopen(nullptr, RTLD_LAZY); if (!self) { std::cerr << dlerror() << "\n"; return 1; } void* function = dlsym(self, argv[1]); if (!function) { std::cerr << dlerror() << "\n"; return 1; } reinterpret_cast<void(*)()>(function)(); dlclose(self); } 

Then compile with the -rdynamic option so all symbols are exported:

$ g++ test.cpp -o test -ldl -rdynamic 

And it works:

$ ./test test void test() $ ./test test2 test2 $ ./test test3 ./test: undefined symbol: test3 

Of course, doing this is a terrible idea:

$ ./test _Z42something_the_user_is_not_supposed_to_callv Oops... $ ./test abort Aborted (core dumped) $ ./test sleep ^C $ ./test main Segmentation fault (core dumped) 

P2996 (which will hopefully be included in C++26) adds reflection to C++.

If we define the functions in a namespace:

namespace funcs { int function_1(int i, int j) { return i * j; } int function_2(int i, int j) { return i / j; } // ... int function_N(int i, int j) { return i + j; } } 

we can implement callFunction as follows:

int callFunction(int i, int j, std::string_view identifier) { using Signature = int(int, int); static constexpr auto idProj = [](const auto& x) { return std::get<0>(x); }; static constexpr auto funcMap = [] { // This is consteval-only, so we need to convert it to something else constexpr auto funcNamespace = ^^funcs; constexpr auto ctx = std::meta::access_context::current(); auto members = std::meta::members_of(funcNamespace, ctx); constexpr auto size = std::meta::members_of(funcNamespace, ctx).size(); // Make a sorted map-like array (pairs of identifier and pointer) std::array<std::pair<std::string_view, Signature*>, size> array; std::ranges::partial_sort_copy( std::views::zip( members | std::views::transform(std::meta::identifier_of), members | std::views::transform(std::meta::extract<Signature*>) ), array, {}, idProj, idProj ); return array; }(); auto iter = std::ranges::lower_bound(funcMap, identifier, {}, idProj); if (iter == funcMap.end() || iter->first != identifier) { throw std::runtime_error("function not found"); } return iter->second(i, j); } 

You can try it on Compiler Explorer.

This implementation can be simplified once constexpr std::flat_map and std::inplace_vector are available. You may also want to do some filtering with has_identifier, is_function and type_of.